Encryption Using AES

The Advanced Encryption Standard or AES is a method of encrypting text to produce encrypted text (ciphertext).

Go

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/base64"
    "errors"
    "io"
    "log"
)

func main() {
 CIPHER_KEY := []byte("This is your key")
 msg := "Hello Universe!"

    if encrypted, err := encrypt(CIPHER_KEY, msg); err != nil {
        log.Println(err)
    } else {
        log.Printf("CIPHER KEY: %s\n", string(CIPHER_KEY))
        log.Printf("ENCRYPTED: %s\n", encrypted)

        if decrypted, err := decrypt(CIPHER_KEY, encrypted); err != nil {
            log.Println(err)
        } else {
            log.Printf("DECRYPTED: %s\n", decrypted)
        }
    }
}

func encrypt(key []byte, message string) (encmess string, err error) {
    plainText := []byte(message)

    block, err := aes.NewCipher(key)
    if err != nil {
        return
    }

    cipherText := make([]byte, aes.BlockSize+len(plainText))
    iv := cipherText[:aes.BlockSize]
    if _, err = io.ReadFull(rand.Reader, iv); err != nil {
        return
    }

    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(cipherText[aes.BlockSize:], plainText)

    encmess = base64.URLEncoding.EncodeToString(cipherText)
    return
}

func decrypt(key []byte, securemess string) (decodedmess string, err error) {
    cipherText, err := base64.URLEncoding.DecodeString(securemess)
    if err != nil {
        return
    }

    block, err := aes.NewCipher(key)
    if err != nil {
        return
    }

    if len(cipherText) < aes.BlockSize {
        err = errors.New("Ciphertext block size is too short!")
        return
    }

    iv := cipherText[:aes.BlockSize]
    cipherText = cipherText[aes.BlockSize:]

    stream := cipher.NewCFBDecrypter(block, iv)
    stream.XORKeyStream(cipherText, cipherText)

    decodedmess = string(cipherText)
    return
}

Console Output:

α go run AES.go
CIPHER KEY: This is your key
ENCRYPTED: 7COvd0-MYFOWjY-i9Gq-qrOZ_nKglwG0zH39IWxcHA==
DECRYPTED: Hello Universe!

NodeJS

var crypto = require("crypto");
var iv = new Buffer("0000000000000000");
var encrypt = function (data, key) {
  var decodeKey = crypto.createHash("sha256").update(key, "utf-8").digest();
  var cipher = crypto.createCipheriv("aes-256-cbc", decodeKey, iv);
  return cipher.update(data, "utf8", "hex") + cipher.final("hex");
};
var decrypt = function (data, key) {
  var encodeKey = crypto.createHash("sha256").update(key, "utf-8").digest();
  var cipher = crypto.createDecipheriv("aes-256-cbc", encodeKey, iv);
  return cipher.update(data, "hex", "utf8") + cipher.final("utf8");
};
var data = "Hello Universe!";
var key = "This is your key";
var cipher = encrypt(data, key);
var decipher = decrypt(cipher, key);
console.log(cipher);
console.log(decipher);

Console Output:

α node --no-deprecation AES.js
8772375cc4eee9201f889996951f4030
Hello Universe!

Java:

import java.security.MessageDigest;

import javax.crypto.Cipher;
import javax.crypto.spec.*;
import javax.xml.bind.DatatypeConverter;

public class AES {
    private static byte[] iv = "0000000000000000".getBytes();

    private static String decrypt(String encrypted, String seed) throws Exception {
        byte[] keyBytes = seed.getBytes("utf-8");
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] digestBytes = md.digest(keyBytes);
        SecretKeySpec skey = new SecretKeySpec(digestBytes, "AES");
        Cipher decryptCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        decryptCipher.init(Cipher.DECRYPT_MODE, skey, new IvParameterSpec(iv));

        byte[] finalBytes = decryptCipher.doFinal(DatatypeConverter.parseHexBinary(encrypted));
        return new String(finalBytes);
    }

    public static String encrypt(String content, String key) throws Exception {
        byte[] inputBytes = content.getBytes("utf-8");

        MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
        byte[] digestBytes = messageDigest.digest(key.getBytes("utf-8"));
        SecretKeySpec skc = new SecretKeySpec(digestBytes, "AES");
        Cipher encryptCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        encryptCipher.init(Cipher.ENCRYPT_MODE, skc, new IvParameterSpec(iv));

        byte[] cipherBytes = new byte[encryptCipher.getOutputSize(inputBytes.length)];
        int ctLength = encryptCipher.update(inputBytes, 0, inputBytes.length, cipherBytes, 0);
        ctLength += encryptCipher.doFinal(cipherBytes, ctLength);
        return DatatypeConverter.printHexBinary(cipherBytes);
    }

    public static void main(String[] args) throws Exception {
        String data = "Hello Universe!";
        String key = "This is your key"; //put secret key here
        String cipher = AES.encrypt(data, key);
        String decipher = AES.decrypt(cipher, key);
        System.out.println(cipher);
        System.out.println(decipher);
    }
}

Console Output:

Please add Java Cryptography Extension to your "${java.home}/jre/lib/security/".

 α java AES
6E760D08F9CE1C8C9F5B1803A590C4B1
Hello Universe!