How to use

Mac

in

javax.crypto

private ByteString hmac(String algorithm, ByteString key) {
 try {
  Mac mac = Mac.getInstance(algorithm);
  mac.init(new SecretKeySpec(key.toByteArray(), algorithm));
  return ByteString.of(mac.doFinal(data));
 } catch (NoSuchAlgorithmException e) {
  throw new AssertionError(e);
 } catch (InvalidKeyException e) {
  throw new IllegalArgumentException(e);
 }
}

 @Override
 public String digestParams(RestInvocation restInvocation) {

  MessageDigest sha256;
  try {
   sha256 = MessageDigest.getInstance("SHA-256");
  } catch (NoSuchAlgorithmException e) {
   throw new RuntimeException(
     "Illegal algorithm for post body digest. Check the implementation.");
  }
  sha256.update(restInvocation.getParamValue(FormParam.class, "nonce").toString().getBytes());
  sha256.update(restInvocation.getRequestBody().getBytes());

  Mac mac512 = getMac();
  mac512.update(("/" + restInvocation.getPath()).getBytes());
  mac512.update(sha256.digest());

  return Base64.getEncoder().encodeToString(mac512.doFinal()).trim();
 }
}

private static Mac getMac(String algorithmName, Key key) {
 try {
  Mac mac = Mac.getInstance(algorithmName);
  mac.init(key);
  return mac;
 } catch (NoSuchAlgorithmException e) {
  throw new IllegalStateException(e);
 } catch (InvalidKeyException e) {
  throw new IllegalArgumentException(e);
 }
}

public byte[] hmac(byte[] key, byte[] bytes) throws InvalidKeyException {
  mac.init(new SecretKeySpec(key, mac.getAlgorithm()));
  return mac.doFinal(bytes);
}

private static Mac initMac(byte[] key) {
  // Java forbids empty keys
  if (key.length == 0) {
    key = new byte[1];
  }
  try {
    Mac mac = Mac.getInstance("HmacSHA256");
    mac.init(new SecretKeySpec(key, "HmacSHA256"));
    return mac;
  } catch (GeneralSecurityException e) {
    throw new RuntimeException(e);
  }
}

try {
  MessageDigest digest = MessageDigest.getInstance("SHA-1");
  digest.update("putty-private-key-file-mac-key".getBytes());
  if (passphrase != null) {
    digest.update(passphrase.getBytes());
  final byte[] key = digest.digest();
  final Mac mac = Mac.getInstance("HmacSHA1");
  mac.init(new SecretKeySpec(key, 0, 20, mac.getAlgorithm()));
  data.write(privateKey);
  final String encoded = Hex.toHexString(mac.doFinal(out.toByteArray()));
  final String reference = headers.get("Private-MAC");
  if (!encoded.equals(reference)) {

Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
byte keyspec[] = cipher.doFinal(ace.encryptedKey);
SecretKeySpec secretKey = new SecretKeySpec(keyspec, ver.getCipherAlgorithm().jceId);
x509Hmac.init(secretKey);
byte certVerifier[] = x509Hmac.doFinal(ace.x509.getEncoded());

MessageDigest md = MessageDigest.getInstance("SHA1");
md.update(encoded);
byte[] fingerprint = md.digest();
Cipher keyCipher = Cipher.getInstance(keyAlgorithm);
keyCipher.init(Cipher.WRAP_MODE, _privateKey);
byte[] encKey = keyCipher.wrap(sharedKey);
_out.writeBytes(encKey);
_mac = Mac.getInstance(_algorithm);
_mac.init(sharedKey);

final Mac mac = Mac.getInstance(getMechanism().getHmacName());
final MessageDigest messageDigest = MessageDigest.getInstance(getMechanism().getMessageDigestName());
mac.reset();
byte[] saltedPassword = initialResult.getScramDigestPassword().getDigest();
mac.init(new SecretKeySpec(saltedPassword, mac.getAlgorithm()));
mac.update(ScramUtil.CLIENT_KEY_BYTES);
clientKey = mac.doFinal();
if(trace) saslScram.tracef("[S] Client key: %s%n", ByteIterator.ofBytes(clientKey).hexEncode().drainToString());
mac.reset();
mac.init(new SecretKeySpec(storedKey, mac.getAlgorithm()));
final byte[] clientFirstMessage = clientMessage.getInitialResponse().getRawMessageBytes();
final int clientFirstMessageBareStart = clientMessage.getInitialResponse().getInitialPartIndex();
mac.update(clientFirstMessage, clientFirstMessageBareStart, clientFirstMessage.length - clientFirstMessageBareStart);
if(trace) saslScram.tracef("[S] Using client first message: %s%n", ByteIterator.ofBytes(copyOfRange(clientFirstMessage, clientFirstMessageBareStart, clientFirstMessage.length)).hexEncode().drainToString());
mac.update((byte) ',');
final byte[] serverFirstMessage = initialResult.getScramInitialChallenge().getRawMessageBytes();
mac.update(serverFirstMessage);
if(trace) saslScram.tracef("[S] Using server first message: %s%n", ByteIterator.ofBytes(serverFirstMessage).hexEncode().drainToString());
mac.update((byte) ',');
final byte[] response = clientMessage.getRawMessageBytes();
final int proofOffset = clientMessage.getProofOffset();
mac.update(response, 0, proofOffset); // client-final-message-without-proof
if(trace) saslScram.tracef("[S] Using client final message without proof: %s%n", ByteIterator.ofBytes(copyOfRange(response, 0, proofOffset)).hexEncode().drainToString());
byte[] clientSignature = mac.doFinal();
if(trace) saslScram.tracef("[S] Client signature: %s%n", ByteIterator.ofBytes(clientSignature).hexEncode().drainToString());
mac.reset();

MessageDigest messageDigest = MessageDigest.getInstance("SHA1");
byte[] checksum = Arrays.copyOfRange(blobBytes, blobBytes.length-20, blobBytes.length); // checksum
Key base = new SecretKeySpec(Arrays.copyOfRange(messageDigest.digest(clampArray(sharedKey, 96)), 0, 16), "HmacSHA1");
Mac mac = Mac.getInstance("HmacSHA1");
mac.init(base);
Key checksumKey = new SecretKeySpec(mac.doFinal("checksum".getBytes()), "HmacSHA1");
Mac checksumMac = Mac.getInstance("HmacSHA1");
checksumMac.init(checksumKey);
byte[] actualChecksum = checksumMac.doFinal(encrypted);
assert Arrays.equals(checksum, actualChecksum);
Key encryptionKey = new SecretKeySpec(Arrays.copyOfRange(mac.doFinal("encryption".getBytes()), 0, 16), "AES");
Cipher cipher = Cipher.getInstance("AES/CTR/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, encryptionKey,new IvParameterSpec(iv));
byte[] decrypted = cipher.doFinal(encrypted);
String decryptedBlob = new String(decrypted);

private byte[] decipherCache(byte[] bundle) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException{
  Cipher cipher;
  byte[] ivData;
  IvParameterSpec iv;
  Mac mac;
  byte[] cipheredContent;
  byte[] decipheredContent;
        cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");       
  mac = Mac.getInstance("HmacSHA1");
  mac.init(new SecretKeySpec(this.keyHMAC, "HmacSHA1"));
  
  if (bundle.length < cipher.getBlockSize()+mac.getMacLength()){
    return null; /* null - correto */ 
  }
  
  cipheredContent = Arrays.copyOfRange(bundle, cipher.getBlockSize()+mac.getMacLength(),bundle.length);
  if (!Arrays.equals(mac.doFinal(cipheredContent), Arrays.copyOfRange(bundle, cipher.getBlockSize(),cipher.getBlockSize()+mac.getMacLength()))){
    return null;
  }
  
  ivData = Arrays.copyOfRange(bundle, 0, cipher.getBlockSize());
  iv = new IvParameterSpec(ivData);
  cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(this.keyAES, "AES"), iv);        
  decipheredContent = cipher.doFinal(cipheredContent);
  
  long cacheDate = ((ByteBuffer) (ByteBuffer.allocate(Long.SIZE / Byte.SIZE).put(Arrays.copyOfRange(decipheredContent, 0, 8)).flip())).getLong();
  return cacheStatus.isValid(cacheDate) ? Arrays.copyOfRange(decipheredContent, 8, decipheredContent.length) : null;        
}
 

SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
IvParameterSpec ivSpec = new IvParameterSpec(keyBytes);
mac.init(keySpec);
verifyMac(mac.doFinal(ciphertext), macBytes);
cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec);
byte[] results = cipher.doFinal(ciphertext);
return new String(results, "UTF-8");
MessageDigest sha = MessageDigest.getInstance("SHA1");
byte[] mac1_hash = sha.digest(mac1);
sha.reset();
byte[] mac2_hash = sha.digest(mac2);

final Mac mac = Mac.getInstance(getMechanism().getHmacName());
final MessageDigest messageDigest = MessageDigest.getInstance(getMechanism().getMessageDigestName());
mac.init(new SecretKeySpec(saltedPassword, mac.getAlgorithm()));
final byte[] clientKey = mac.doFinal(ScramUtil.CLIENT_KEY_BYTES);
if(trace) saslScram.tracef("[C] Client key: %s", ByteIterator.ofBytes(clientKey).hexEncode().drainToString());
final byte[] storedKey = messageDigest.digest(clientKey);
if(trace) saslScram.tracef("[C] Stored key: %s%n", ByteIterator.ofBytes(storedKey).hexEncode().drainToString());
mac.init(new SecretKeySpec(storedKey, mac.getAlgorithm()));
final byte[] initialResponseBytes = initialResponse.getRawMessageBytes();
mac.update(initialResponseBytes, initialResponse.getInitialPartIndex(), initialResponseBytes.length - initialResponse.getInitialPartIndex());
if (trace) saslScram.tracef("[C] Using client first message: %s%n", ByteIterator.ofBytes(initialResponseBytes, initialResponse.getInitialPartIndex(), initialResponseBytes.length - initialResponse.getInitialPartIndex()).hexEncode().drainToString());
mac.update((byte) ',');
mac.update(initialChallenge.getRawMessageBytes());
if(trace) saslScram.tracef("[C] Using server first message: %s%n", ByteIterator.ofBytes(initialChallenge.getRawMessageBytes()).hexEncode().drainToString());
mac.update((byte) ',');
encoded.updateMac(mac);
if(trace) saslScram.tracef("[C] Using client final message without proof: %s%n", ByteIterator.ofBytes(encoded.toArray()).hexEncode().drainToString());
final byte[] clientProof = mac.doFinal();
if(trace) saslScram.tracef("[C] Client signature: %s%n", ByteIterator.ofBytes(clientProof).hexEncode().drainToString());
ScramUtil.xor(clientProof, clientKey);

 @Override
 public String digestParams(RestInvocation restInvocation) {
  try {
   String urlMethod = restInvocation.getInvocationUrl();
   String nonce = String.valueOf(nonceFactory.createValue());

   String body = restInvocation.getRequestBody();
   String md5 =
     Base64.getEncoder()
       .encodeToString(MessageDigest.getInstance("MD5").digest(body.getBytes("UTF-8")));

   String reqSignature =
     apiKey
       + "POST"
       + URLEncoder.encode(urlMethod, StandardCharsets.UTF_8.toString()).toLowerCase()
       + nonce
       + md5;

   return "amx "
     + apiKey
     + ":"
     + Base64.getEncoder().encodeToString(getMac().doFinal(reqSignature.getBytes("UTF-8")))
     + ":"
     + nonce;
  } catch (Exception e) {
   throw new IllegalStateException("Faile to sign request", e);
  }
 }
}

 String message = "[1312701386,transactioncreate,[account_code:ABC,amount_in_cents:5000,currency:USD]]";
String privateKey = "0123456789ABCDEF0123456789ABCDEF";

MessageDigest md = MessageDigest.getInstance("SHA-1");
byte[] keyBytes = md.digest(privateKey.getBytes("UTF-8"));

SecretKey sk = new SecretKeySpec(keyBytes, "HmacSHA1");
Mac mac = Mac.getInstance("HmacSHA1");
mac.init(sk);
byte[] result = mac.doFinal(message.getBytes("ASCII"));

System.out.println("  Message: " + message);
System.out.println("      Key: " + privateKey + "\n");
System.out.println("Key Bytes: " + toHex(keyBytes));
System.out.println("  Results: " + toHex(result));

@Override
public byte[] encryptData(byte[] plaintext, SecretKey encryptionKey,
  SecretKey hmacKey) throws CryptorException {
 Validate.notNull(plaintext, "Plaintext cannot be null.");
 Validate.notNull(encryptionKey, "Encryption key cannot be null.");
 Validate.notNull(hmacKey, "HMAC key cannot be null.");
 byte[] iv = getSecureRandomData(AES_BLOCK_SIZE);
 try {
  Cipher cipher = Cipher.getInstance(AES_CIPHER_ALGORITHM);
  cipher.init(Cipher.ENCRYPT_MODE, encryptionKey, new IvParameterSpec(iv));
  byte[] ciphertext = cipher.doFinal(plaintext);
  AES256v3Ciphertext output = new AES256v3Ciphertext(iv, ciphertext);
  Mac mac = Mac.getInstance(HMAC_ALGORITHM);
  mac.init(hmacKey);
  byte[] hmac = mac.doFinal(output.getDataToHMAC());
  output.setHmac(hmac);
  return output.getRawData();
 } catch (GeneralSecurityException e) {
  throw new CryptorException("Failed to generate ciphertext.", e);
 }
}

  throw new IllegalArgumentException("Max buffer size should not be less than chunk size");
try {
  this.sha256 = MessageDigest.getInstance("SHA-256");
  final String signingAlgo = SigningAlgorithm.HmacSHA256.toString();
  this.hmacSha256 = Mac.getInstance(signingAlgo);
  hmacSha256.init(new SecretKeySpec(kSigning, signingAlgo));
} catch (NoSuchAlgorithmException e) {
  throw new IllegalStateException(e);

/**
 * Encrypts the next plaintext segment. This uses encryptedSegments as the segment number for
 * the encryption.
 */
@Override
public synchronized void encryptSegment(
  ByteBuffer plaintext, boolean isLastSegment, ByteBuffer ciphertext)
  throws GeneralSecurityException {
 int position = ciphertext.position();
 byte[] nonce = nonceForSegment(noncePrefix, encryptedSegments, isLastSegment);
 cipher.init(Cipher.ENCRYPT_MODE, keySpec, new IvParameterSpec(nonce));
 encryptedSegments++;
 cipher.doFinal(plaintext, ciphertext);
 ByteBuffer ctCopy = ciphertext.duplicate();
 ctCopy.flip();
 ctCopy.position(position);
 mac.init(hmacKeySpec);
 mac.update(nonce);
 mac.update(ctCopy);
 byte[] tag = mac.doFinal();
 ciphertext.put(tag, 0, tagSizeInBytes);
}

private byte[] getCiphertext(byte[] plaintext, SecretKeySpec cipherKey, SecretKeySpec macKey)
  throws CryptoEncodingException
{
 try {
  Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
  cipher.init(Cipher.ENCRYPT_MODE, cipherKey);
  Mac hmac = Mac.getInstance("HmacSHA256");
  hmac.init(macKey);
  hmac.update(VERSION);
  byte[] ivBytes = cipher.getIV();
  hmac.update(ivBytes);
  byte[] ciphertext   = cipher.doFinal(plaintext);
  byte[] mac          = hmac.doFinal(ciphertext);
  byte[] truncatedMac = new byte[MAC_SIZE];
  System.arraycopy(mac, 0, truncatedMac, 0, truncatedMac.length);
  return Util.combine(VERSION, ivBytes, ciphertext, truncatedMac);
 } catch (NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException e) {
  throw new AssertionError(e);
 } catch (InvalidKeyException e) {
  logger.warn("Invalid Key", e);
  throw new CryptoEncodingException("Invalid key!");
 }
}

 /**
  * Returns the hash of the bytes supplied thus far and resets the internal state of this source.
  *
  * <p><strong>Warning:</strong> This method is not idempotent. Each time this method is called its
  * internal state is cleared. This starts a new hash with zero bytes supplied.
  */
 public ByteString hash() {
  byte[] result = messageDigest != null ? messageDigest.digest() : mac.doFinal();
  return ByteString.of(result);
 }
}