Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
BEGIN LICENSE BLOCK ***** Version: CPL 1.0/GPL 2.0/LGPL 2.1 The contents of this file are subject to the Common Public License Version 1.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.eclipse.org/legal/cpl-v10.html Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License. Copyright (C) 2006, 2007 Ola Bini <ola@ologix.com> Alternatively, the contents of this file may be used under the terms of either of the GNU General Public License Version 2 or later (the "GPL"), or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), in which case the provisions of the GPL or the LGPL are applicable instead of those above. If you wish to allow use of your version of this file only under the terms of either the GPL or the LGPL, and not to allow others to use your version of this file under the terms of the CPL, indicate your decision by deleting the provisions above and replace them with the notice and other provisions required by the GPL or the LGPL. If you do not delete the provisions above, a recipient may use your version of this file under the terms of any one of the CPL, the GPL or the LGPL. END LICENSE BLOCK ***
 
 package org.jruby.ext.openssl;
 
 import java.util.List;
 import java.util.Set;
 
 
 import org.jruby.Ruby;

Author(s):
Ola Bini
 
 public class Cipher extends RubyObject {
     private static final long serialVersionUID = 7727377435222646536L;
 
     // set to enable debug output
     private static final boolean DEBUG = false;
     private static ObjectAllocator CIPHER_ALLOCATOR = new ObjectAllocator() {
 
         public IRubyObject allocate(Ruby runtimeRubyClass klass) {
             return new Cipher(runtimeklass);
         }
     };
 
     public static void createCipher(Ruby runtimeRubyModule mOSSL) {
         RubyClass cCipher = mOSSL.defineClassUnder("Cipher"runtime.getObject(), );
         cCipher.defineAnnotatedMethods(Cipher.class);
         cCipher.defineAnnotatedMethods(CipherModule.class);
         RubyClass openSSLError = mOSSL.getClass("OpenSSLError");
         cCipher.defineClassUnder("CipherError"openSSLErroropenSSLError.getAllocator());
     }
 
     @JRubyModule(name = "OpenSSL::Cipher")
     public static class CipherModule {
 
         @JRubyMethod(meta = true)
         public static IRubyObject ciphers(IRubyObject recv) {
             initializeCiphers();
             List<IRubyObjectresult = new ArrayList<IRubyObject>();
             for (String cipher : ) {
                 result.add(recv.getRuntime().newString(cipher));
                 result.add(recv.getRuntime().newString(cipher.toLowerCase()));
             }
             return recv.getRuntime().newArray(result);
         }
 
         public static boolean isSupportedCipher(String name) {
             initializeCiphers();
             return .indexOf(name.toUpperCase()) != -1;
         }
         private static boolean initialized = false;
         private static final List<StringCIPHERS = new ArrayList<String>();
 
         private static void initializeCiphers() {
            synchronized () {
                if () {
                    return;
                }
                String[] other = {"AES128""AES192""AES256""BLOWFISH""RC2-40-CBC""RC2-64-CBC""RC4""RC4-40""CAST""CAST-CBC"};
                String[] bases = {"AES-128""AES-192""AES-256""BF""DES""DES-EDE""DES-EDE3""RC2""CAST5"};
                String[] suffixes = {"""-CBC""-CFB""-CFB1""-CFB8""-ECB""-OFB"};
                for (int i = 0, j = bases.lengthi < ji++) {
                    for (int k = 0, l = suffixes.lengthk < lk++) {
                        String val = bases[i] + suffixes[k];
                        if (tryCipher(val)) {
                            .add(val.toUpperCase());
                        }
                    }
                }
                for (int i = 0, j = other.lengthi < ji++) {
                    if (tryCipher(other[i])) {
                        .add(other[i].toUpperCase());
                    }
                }
                 = true;
            }
        }
    }
    public static class Algorithm {
        private static final Set<StringBLOCK_MODES;
        static {
             = new HashSet<String>();
            .add("CBC");
            .add("CFB");
            .add("CFB1");
            .add("CFB8");
            .add("ECB");
            .add("OFB");
        }
        public static String jsseToOssl(String inNameint keyLen) {
            String cryptoBase = null;
            String cryptoVersion = null;
            String cryptoMode = null;
            String[] parts = inName.split("/");
            if (parts.length != 1 && parts.length != 3) {
                return null;
            }
            cryptoBase = parts[0];
            if (parts.length > 2) {
                cryptoMode = parts[1];
                // padding: parts[2] is not used
            }
            if (!.contains(cryptoMode)) {
                cryptoVersion = cryptoMode;
                cryptoMode = "CBC";
            }
            if (cryptoMode == null) {
                cryptoMode = "CBC";
            }
            if (cryptoBase.equals("DESede")) {
                cryptoBase = "DES";
                cryptoVersion = "EDE3";
            } else if (cryptoBase.equals("Blowfish")) {
                cryptoBase = "BF";
            }
            if (cryptoVersion == null) {
                cryptoVersion = String.valueOf(keyLen);
            }
            return cryptoBase + "-" + cryptoVersion + "-" + cryptoMode;
        }
        public static String getAlgorithmBase(javax.crypto.Cipher cipher) {
            String algoBase = cipher.getAlgorithm();
            if (algoBase.indexOf('/') != -1) {
                algoBase = algoBase.split("/")[0];
            }
            return algoBase;
        }
        
        public static String[] osslToJsse(String inName) {
            // assume PKCS5Padding
            return osslToJsse(inNamenull);
        }
        public static String[] osslToJsse(String inNameString padding) {
            String[] split = inName.split("-");
            String cryptoBase = split[0];
            String cryptoVersion = null;
            String cryptoMode = null;
            String realName = null;
            String paddingType;
            if (padding == null || padding.equalsIgnoreCase("PKCS5Padding")) {
                paddingType = "PKCS5Padding";
            } else if (padding.equals("0") || padding.equalsIgnoreCase("NoPadding")) {
                paddingType = "NoPadding";
            } else if (padding.equalsIgnoreCase("ISO10126Padding")) {
                paddingType = "ISO10126Padding";
            } else {
                paddingType = "PKCS5Padding";
            }
            if ("bf".equalsIgnoreCase(cryptoBase)) {
                cryptoBase = "Blowfish";
            }
            if (split.length == 3) {
                cryptoVersion = split[1];
                cryptoMode = split[2];
            } else if (split.length == 2) {
                cryptoMode = split[1];
            } else {
                cryptoMode = "CBC";
            }
            if (cryptoBase.equalsIgnoreCase("CAST")) {
                realName = "CAST5";
            } else if (cryptoBase.equalsIgnoreCase("DES") && "EDE3".equalsIgnoreCase(cryptoVersion)) {
                realName = "DESede";
            } else {
                realName = cryptoBase;
            }
            if (!.contains(cryptoMode.toUpperCase())) {
                cryptoVersion = cryptoMode;
                cryptoMode = "CBC";
            } else if (cryptoMode.equalsIgnoreCase("CFB1")) {
                // uglish SunJCE cryptoMode normalization.
                cryptoMode = "CFB";
            }
            if (realName.equalsIgnoreCase("RC4")) {
                realName = "RC4";
                cryptoMode = "NONE";
                paddingType = "NoPadding";
            } else {
                realName = realName + "/" + cryptoMode + "/" + paddingType;
            }
            return new String[]{cryptoBasecryptoVersioncryptoModerealNamepaddingType};
        }
        
        public static int[] osslKeyIvLength(String name) {
            String[] values = Algorithm.osslToJsse(name);
            String cryptoBase = values[0];
            String cryptoVersion = values[1];
            String cryptoMode = values[2];
            String realName = values[3];
            int keyLen = -1;
            int ivLen = -1;
            if (hasLen(cryptoBase) && null != cryptoVersion) {
                try {
                    keyLen = Integer.parseInt(cryptoVersion) / 8;
                } catch (NumberFormatException e) {
                    keyLen = -1;
                }
            }
            if (keyLen == -1) {
                if ("DES".equalsIgnoreCase(cryptoBase)) {
                    ivLen = 8;
                    if ("EDE3".equalsIgnoreCase(cryptoVersion)) {
                        keyLen = 24;
                    } else {
                        keyLen = 8;
                    }
                } else if ("RC4".equalsIgnoreCase(cryptoBase)) {
                    ivLen = 0;
                    keyLen = 16;
                } else {
                    keyLen = 16;
                    try {
                        if ((javax.crypto.Cipher.getMaxAllowedKeyLength(name) / 8) < keyLen) {
                            keyLen = javax.crypto.Cipher.getMaxAllowedKeyLength(name) / 8;
                        }
                    } catch (Exception e) {
                        // I hate checked exceptions
                    }
                }
            }
            if (ivLen == -1) {
                if ("AES".equalsIgnoreCase(cryptoBase)) {
                    ivLen = 16;
                } else {
                    ivLen = 8;
                }
            }
            return new int[] { keyLenivLen };
        }
        public static boolean hasLen(String cryptoBase) {
            return "AES".equalsIgnoreCase(cryptoBase) || "RC2".equalsIgnoreCase(cryptoBase) || "RC4".equalsIgnoreCase(cryptoBase);
        }
    }
    private static boolean tryCipher(final String rubyName) {
        String cryptoMode = Algorithm.osslToJsse(rubyNamenull)[3];
        try {
            javax.crypto.Cipher.getInstance(cryptoMode);
            return true;
        } catch (NoSuchAlgorithmException nsae) {
            try {
                OpenSSLReal.getCipherBC(cryptoMode);
                return true;
            } catch (GeneralSecurityException gse) {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
    }
    public Cipher(Ruby runtimeRubyClass type) {
        super(runtimetype);
    }
    private javax.crypto.Cipher ciph;
    private String name;
    private String cryptoBase;
    private String cryptoVersion;
    private String cryptoMode;
    private String padding_type;
    private String realName;
    private int keyLen = -1;
    private int generateKeyLen = -1;
    private int ivLen = -1;
    private boolean encryptMode = true;
    //private IRubyObject[] modeParams;
    private boolean ciphInited = false;
    private byte[] key;
    private byte[] realIV;
    private byte[] orgIV;
    private String padding;
    void dumpVars() {
        ..println("***** Cipher instance vars ****");
        ..println("name = " + );
        ..println("cryptoBase = " + );
        ..println("cryptoVersion = " + );
        ..println("cryptoMode = " + );
        ..println("padding_type = " + );
        ..println("realName = " + );
        ..println("keyLen = " + );
        ..println("ivLen = " + );
        ..println("ciph block size = " + .getBlockSize());
        ..println("encryptMode = " + );
        ..println("ciphInited = " + );
        ..println("key.length = " + ( == null ? 0 : .));
        ..println("iv.length = " + (this. == null ? 0 : this..length));
        ..println("padding = " + );
        ..println("ciphAlgo = " + .getAlgorithm());
        ..println("*******************************");
    }
    @JRubyMethod(required = 1)
    public IRubyObject initialize(IRubyObject str) {
         = str.toString();
        if (!CipherModule.isSupportedCipher()) {
            throw newCipherError(getRuntime(), String.format("unsupported cipher algorithm (%s)"));
        }
        if ( != null) {
            throw getRuntime().newRuntimeError("Cipher already inititalized!");
        }
        updateCipher();
        return this;
    }
    @Override
    @JRubyMethod(required = 1)
    public IRubyObject initialize_copy(IRubyObject obj) {
        if (this == obj) {
            return this;
        }
        checkFrozen();
         = ((Cipherobj).;
         = ((Cipherobj).;
         = ((Cipherobj).;
         = ((Cipherobj).;
         = ((Cipherobj).;
         = ((Cipherobj).;
         = ((Cipherobj).;
         = ((Cipherobj).;
         = ((Cipherobj).;
         = false;
        if (((Cipherobj). != null) {
             = new byte[((Cipherobj)..length];
            System.arraycopy(((Cipherobj)., 0, , 0, .);
        } else {
             = null;
        }
        if (((Cipherobj). != null) {
            this. = new byte[((Cipherobj)..length];
            System.arraycopy(((Cipherobj)., 0, this., 0, this..length);
        } else {
            this. = null;
        }
        this. = this.;
         = ((Cipherobj).;
         = getCipher();
        return this;
    }
    public IRubyObject name() {
        return getRuntime().newString();
    }
    public IRubyObject key_len() {
        return getRuntime().newFixnum();
    }
    public IRubyObject iv_len() {
        return getRuntime().newFixnum();
    }
    @JRubyMethod(name = "key_len=", required = 1)
    public IRubyObject set_key_len(IRubyObject len) {
        this. = RubyNumeric.fix2int(len);
        return len;
    }
    @JRubyMethod(name = "key=", required = 1)
    public IRubyObject set_key(IRubyObject key) {
        byte[] keyBytes;
        try {
            keyBytes = key.convertToString().getBytes();
        } catch (Exception e) {
            if () {
                e.printStackTrace();
            }
            throw newCipherError(getRuntime(), e.getMessage());
        }
        if (keyBytes.length < ) {
            throw newCipherError(getRuntime(), "key length to short");
        }
        if (keyBytes.length > ) {
            byte[] keys = new byte[];
            System.arraycopy(keyBytes, 0, keys, 0, );
            keyBytes = keys;
        }
        this. = keyBytes;
        return key;
    }
    @JRubyMethod(name = "iv=", required = 1)
    public IRubyObject set_iv(IRubyObject iv) {
        byte[] ivBytes;
        try {
            ivBytes = iv.convertToString().getBytes();
        } catch (Exception e) {
            if () {
                e.printStackTrace();
            }
            throw newCipherError(getRuntime(), e.getMessage());
        }
        if (ivBytes.length < ) {
            throw newCipherError(getRuntime(), "iv length to short");
        } else {
            // EVP_CipherInit_ex uses leading IV length of given sequence.
            byte[] iv2 = new byte[];
            System.arraycopy(ivBytes, 0, iv2, 0, );
            this. = iv2;
        }
        this. = this.;
        if (!isStreamCipher()) {
             = false;
        }
        return iv;
    }
    public IRubyObject block_size() {
        checkInitialized();
        if (isStreamCipher()) {
            // getBlockSize() returns 0 for stream cipher in JCE. OpenSSL returns 1 for RC4.
            return getRuntime().newFixnum(1);
        }
        return getRuntime().newFixnum(.getBlockSize());
    }
    protected void init(IRubyObject[] argsboolean encrypt) {
        org.jruby.runtime.Arity.checkArgumentCount(getRuntime(), args, 0, 2);
         = encrypt;
         = false;
        if (args.length > 0) {
            /*
             * oops. this code mistakes salt for IV.
             * We deprecated the arguments for this method, but we decided
             * keeping this behaviour for backward compatibility.
             */
            byte[] pass = args[0].convertToString().getBytes();
            byte[] iv = null;
            try {
                iv = "OpenSSL for Ruby rulez!".getBytes("ISO8859-1");
                byte[] iv2 = new byte[this.];
                System.arraycopy(iv, 0, iv2, 0, this.);
                iv = iv2;
            } catch (Exception e) {
            }
            if (args.length > 1 && !args[1].isNil()) {
                getRuntime().getWarnings().warning(."key derivation by " + getMetaClass().getRealClass().getName() + "#encrypt is deprecated; use " + getMetaClass().getRealClass().getName() + "::pkcs5_keyivgen instead");
                iv = args[1].convertToString().getBytes();
                if (iv.length > this.) {
                    byte[] iv2 = new byte[this.];
                    System.arraycopy(iv, 0, iv2, 0, this.);
                    iv = iv2;
                }
            }
            MessageDigest digest = Digest.getDigest("MD5"getRuntime());
            OpenSSLImpl.KeyAndIv result = OpenSSLImpl.EVP_BytesToKey(digestivpass, 2048);
            this. = result.getKey();
            this. = iv;
            this. = this.;
        }
    }
    @JRubyMethod(optional = 2)
    public IRubyObject encrypt(IRubyObject[] args) {
        this. = ;
        init(argstrue);
        return this;
    }
    @JRubyMethod(optional = 2)
    public IRubyObject decrypt(IRubyObject[] args) {
        this. = ;
        init(argsfalse);
        return this;
    }
    public IRubyObject reset() {
        checkInitialized();
        if (!isStreamCipher()) {
            this. = ;
            doInitialize();
        }
        return this;
    }
    private void updateCipher(String nameString padding) {
        // given 'rc4' must be 'RC4' here. OpenSSL checks it as a LN of object
        // ID and set SN. We don't check 'name' is allowed as a LN in ASN.1 for
        // the possibility of JCE specific algorithm so just do upperCase here
        // for OpenSSL compatibility.
        this. = name.toUpperCase();
        this. = padding;
        String[] values = Algorithm.osslToJsse(namepadding);
         = values[0];
         = values[1];
         = values[2];
         = values[3];
         = values[4];
        int[] lengths = Algorithm.osslKeyIvLength(name);
         = lengths[0];
         = lengths[1];
        if ("DES".equalsIgnoreCase()) {
             =  / 8 * 7;
        }
         = getCipher();
    }
        try {
            return javax.crypto.Cipher.getInstance();
        } catch (NoSuchAlgorithmException e) {
            try {
                return OpenSSLReal.getCipherBC();
            } catch (GeneralSecurityException ignore) {
            }
            throw newCipherError(getRuntime(), "unsupported cipher algorithm (" +  + ")");
        } catch (javax.crypto.NoSuchPaddingException e) {
            throw newCipherError(getRuntime(), "unsupported cipher padding (" +  + ")");
        }
    }
    @JRubyMethod(required = 1, optional = 3)
    public IRubyObject pkcs5_keyivgen(IRubyObject[] args) {
        org.jruby.runtime.Arity.checkArgumentCount(getRuntime(), args, 1, 4);
        byte[] pass = args[0].convertToString().getBytes();
        byte[] salt = null;
        int iter = 2048;
        IRubyObject vdigest = getRuntime().getNil();
        if (args.length > 1) {
            if (!args[1].isNil()) {
                salt = args[1].convertToString().getBytes();
            }
            if (args.length > 2) {
                if (!args[2].isNil()) {
                    iter = RubyNumeric.fix2int(args[2]);
                }
                if (args.length > 3) {
                    vdigest = args[3];
                }
            }
        }
        if (null != salt) {
            if (salt.length != 8) {
                throw newCipherError(getRuntime(), "salt must be an 8-octet string");
            }
        }
        final String algorithm = vdigest.isNil() ? "MD5" : ((Digestvdigest).getAlgorithm();
        MessageDigest digest = Digest.getDigest(algorithmgetRuntime());
        OpenSSLImpl.KeyAndIv result = OpenSSLImpl.EVP_BytesToKey(digestsaltpassiter);
        this. = result.getKey();
        this. = result.getIv();
        this. = this.;
        doInitialize();
        return getRuntime().getNil();
    }
    private void doInitialize() {
        if () {
            ..println("*** doInitialize");
            dumpVars();
        }
        checkInitialized();
        if ( == null) {
            throw newCipherError(getRuntime(), "key not specified");
        }
        try {
            if (!"ECB".equalsIgnoreCase()) {
                if (this. == null) {
                    this. = new byte[];
                    System.arraycopy("OpenSSL for JRuby rulez".getBytes(), 0,
                            this., 0, );
                }
                if ("RC2".equalsIgnoreCase()) {
                    this..init( ? ... : ...new SimpleSecretKey("RC2"this.), new RC2ParameterSpec(this..length * 8, this.));
                } else if ("RC4".equalsIgnoreCase()) {
                    this..init( ? ... : ...new SimpleSecretKey("RC4"this.));
                } else {
                    this..init( ? ... : ...new SimpleSecretKey(.split("/")[0], this.), new IvParameterSpec(this.));
                }
            } else {
                this..init( ? ... : ...new SimpleSecretKey(.split("/")[0], this.));
            }
        } catch (java.security.InvalidKeyException ike) {
            throw newCipherError(getRuntime(), ike.getMessage() + ": possibly you need to install Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files for your JRE");
        } catch (Exception e) {
            if () {
                e.printStackTrace();
            }
            throw newCipherError(getRuntime(), e.getMessage());
        }
         = true;
    }
    private byte[] lastIv = null;
    public IRubyObject update(IRubyObject data) {
        if () {
            ..println("*** update [" + data + "]");
        }
        checkInitialized();
        byte[] val = data.convertToString().getBytes();
        if (val.length == 0) {
            throw getRuntime().newArgumentError("data must not be empty");
        }
        if (!) {
            if () {
                ..println("BEFORE INITING");
            }
            doInitialize();
            if () {
                ..println("AFTER INITING");
            }
        }
        byte[] str = new byte[0];
        try {
            byte[] out = .update(val);
            if (out != null) {
                str = out;
                if (this. != null) {
                    if ( == null) {
                         = new byte[];
                    }
                    byte[] tmpIv =  ? out : val;
                    if (tmpIv.length >= ) {
                        System.arraycopy(tmpIvtmpIv.length - , 0, );
                    }
                }
            }
        } catch (Exception e) {
            if () {
                e.printStackTrace();
            }
            throw newCipherError(getRuntime(), e.getMessage());
        }
        return getRuntime().newString(new ByteList(strfalse));
    }
    @JRubyMethod(name = "<<")
    public IRubyObject update_deprecated(IRubyObject data) {
        getRuntime().getWarnings().warn(.."" + this.getMetaClass().getRealClass().getName() + "#<< is deprecated; use " + this.getMetaClass().getRealClass().getName() + "#update instead");
        return update(data);
    }
    @JRubyMethod(name = "final")
    public IRubyObject _final() {
        checkInitialized();
        if (!) {
            doInitialize();
        }
        // trying to allow update after final like cruby-openssl. Bad idea.
        if ("RC4".equalsIgnoreCase()) {
            return getRuntime().newString("");
        }
        ByteList str = new ByteList(.);
        try {
            byte[] out = .doFinal();
            if (out != null) {
                str = new ByteList(outfalse);
                // TODO: Modifying this line appears to fix the issue, but I do
                // not have a good reason for why. Best I can tell, lastIv needs
                // to be set regardless of encryptMode, so we'll go with this
                // for now. JRUBY-3335.
                //if(this.realIV != null && encryptMode) {
                if (this. != null) {
                    if ( == null) {
                         = new byte[];
                    }
                    byte[] tmpIv = out;
                    if (tmpIv.length >= ) {
                        System.arraycopy(tmpIvtmpIv.length - , 0, );
                    }
                }
            }
            if (this. != null) {
                this. = ;
                doInitialize();
            }
        } catch (Exception e) {
            throw newCipherError(getRuntime(), e.getMessage());
        }
        return getRuntime().newString(str);
    }
    @JRubyMethod(name = "padding=")
    public IRubyObject set_padding(IRubyObject padding) {
        updateCipher(padding.toString());
        return padding;
    }
    String getAlgorithm() {
        return this..getAlgorithm();
    }
    String getName() {
        return this.;
    }
    String getCryptoBase() {
        return this.;
    }
    String getCryptoMode() {
        return this.;
    }
    int getKeyLen() {
        return ;
    }
    
    int getGenerateKeyLen() {
        return ( == -1) ?  : ;
    }
    
    private void checkInitialized() {
        if ( == null) {
            throw getRuntime().newRuntimeError("Cipher not inititalized!");
        }
    }
    
    private boolean isStreamCipher() {
        return .getBlockSize() == 0;
    }
    private static RaiseException newCipherError(Ruby runtimeString message) {
        return Utils.newError(runtime"OpenSSL::Cipher::CipherError"message);
    }