Java Base64.encode方法代碼示例

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Bitcoin messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, @Nullable KeyParameter aesKey) throws KeyCrypterException {
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.twiceOf(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && k.pub.equals(pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Bitcoin messaging signing format
 * and returns the signature as a base64 encoded string.
 * 
 * Some blockchains require additional header bytes infront of the message.
 * <code>[24] "Bitcoin Signed Message:\n" [message.length as a varint] message</code>
 * 
 * @param headerBytes
 *            the additional header bytes required by the blockchain.
 * @throws IllegalStateException
 *             if this ECKey does not have the private part.
 * @throws KeyCrypterException
 *             if this ECKey is encrypted and no AESKey is provided or it
 *             does not decrypt the ECKey.
 */
public String signMessage(String message, Charset charset, @Nullable KeyParameter aesKey,
        @Nullable byte[] headerBytes) {
    byte[] data = CryptoUtils.formatMessageForSigning(message, charset, headerBytes);
    Sha256Hash hash = Sha256Hash.twiceOf(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to
    // recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && k.pub.equals(pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65]; // 1 header + 32 bytes for R + 32 bytes
                                   // for S
    sigData[0] = (byte) headerByte;
    System.arraycopy(CryptoUtils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(CryptoUtils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Bitcoin messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 */
public String signMessage(String message) {
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.twiceOf(data);
    ECDSASignature sig = sign(hash);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        BtcECKey k = BtcECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && k.pub.equals(pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard NithPoints messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, KeyParameter aesKey) throws KeyCrypterException {
    if (priv == null)
        throw new IllegalStateException("This ECKey does not have the private key necessary for signing.");
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.createDouble(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && Arrays.equals(k.pub, pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
private void writeEncoded(byte[] bytes)
    throws IOException
{
    bytes = Base64.encode(bytes);

    for (int i = 0; i < bytes.length; i += buf.length)
    {
        int index = 0;

        while (index != buf.length)
        {
            if ((i + index) >= bytes.length)
            {
                break;
            }
            buf[index] = (char)bytes[i + index];
            index++;
        }
        this.write(buf, 0, index);
        this.newLine();
    }
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Bitcoin messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, @Nullable KeyParameter aesKey) throws KeyCrypterException {
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.createDouble(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && k.pub.equals(pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * @summary Method to generate a new salt key
 * @return  {String} The newly generated salt key
 */
public static String generateSaltKey()
    throws UnsupportedEncodingException {

    SecureRandom csprng = new SecureRandom();
    byte[] saltKeyBytes = new byte[SALT_KEY_LENGTH];
    csprng.nextBytes(saltKeyBytes);
    String saltKey = null;
    try {
        saltKey = new String(Base64.encode(saltKeyBytes), UTF8);
    } catch (UnsupportedEncodingException e) {
        // Throw it to the caller.
        throw e;
    }
    return saltKey;
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Bitcoin messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, @Nullable KeyParameter aesKey) throws KeyCrypterException {
    if (priv == null)
        throw new IllegalStateException("This ECKey does not have the private key necessary for signing.");
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.createDouble(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && Arrays.equals(k.pub, pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Nubits messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, @Nullable KeyParameter aesKey) throws KeyCrypterException {
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.twiceOf(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && k.pub.equals(pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
@Override
public String encrypt(String plainString) {
    if (plainString == null) {
        throw new IllegalArgumentException("PlainString must not be null");
    }

    try {
        byte[] plainStringBytes = plainString.getBytes(ENCODING);
        byte[] encodedText = new byte[plainStringBytes.length];

        salsa20Engine.processBytes(plainStringBytes, 0, plainStringBytes.length, encodedText, 0);

        byte[] protectedBuffer = Base64.encode(encodedText);

        return new String(protectedBuffer, ENCODING);
    } catch (UnsupportedEncodingException e) {
        throw new UnsupportedOperationException(MSG_UNKNOWN_UTF8_ENCODING, e);
    }
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Bitcoin messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, KeyParameter aesKey) throws KeyCrypterException {
    if (priv == null)
        throw new IllegalStateException("This ECKey does not have the private key necessary for signing.");
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.createDouble(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && Arrays.equals(k.pub, pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Peercoin messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, @Nullable KeyParameter aesKey) throws KeyCrypterException {
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.createDouble(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && k.pub.equals(pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Litecoin messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException   if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, KeyParameter aesKey) throws KeyCrypterException {
    if (priv == null)
        throw new IllegalStateException("This ECKey does not have the private key necessary for signing.");
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.createDouble(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && Arrays.equals(k.pub, pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte) headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Feathercoin messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, KeyParameter aesKey) throws KeyCrypterException {
    if (priv == null)
        throw new IllegalStateException("This ECKey does not have the private key necessary for signing.");
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.createDouble(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && Arrays.equals(k.pub, pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}
 

import org.spongycastle.util.encoders.Base64; //導入方法依賴的package包/類
/**
 * Signs a text message using the standard Anoncoin messaging signing format and returns the signature as a base64
 * encoded string.
 *
 * @throws IllegalStateException if this ECKey does not have the private part.
 * @throws KeyCrypterException if this ECKey is encrypted and no AESKey is provided or it does not decrypt the ECKey.
 */
public String signMessage(String message, KeyParameter aesKey) throws KeyCrypterException {
    if (priv == null)
        throw new IllegalStateException("This ECKey does not have the private key necessary for signing.");
    byte[] data = Utils.formatMessageForSigning(message);
    Sha256Hash hash = Sha256Hash.createDouble(data);
    ECDSASignature sig = sign(hash, aesKey);
    // Now we have to work backwards to figure out the recId needed to recover the signature.
    int recId = -1;
    for (int i = 0; i < 4; i++) {
        ECKey k = ECKey.recoverFromSignature(i, sig, hash, isCompressed());
        if (k != null && Arrays.equals(k.pub, pub)) {
            recId = i;
            break;
        }
    }
    if (recId == -1)
        throw new RuntimeException("Could not construct a recoverable key. This should never happen.");
    int headerByte = recId + 27 + (isCompressed() ? 4 : 0);
    byte[] sigData = new byte[65];  // 1 header + 32 bytes for R + 32 bytes for S
    sigData[0] = (byte)headerByte;
    System.arraycopy(Utils.bigIntegerToBytes(sig.r, 32), 0, sigData, 1, 32);
    System.arraycopy(Utils.bigIntegerToBytes(sig.s, 32), 0, sigData, 33, 32);
    return new String(Base64.encode(sigData), Charset.forName("UTF-8"));
}