介绍XXTEA加密算法

TEA算法是由剑桥大学计算机实验室的David Wheeler和Roger Needham于1994年发明，TEA是Tiny Encryption Algorithm的缩写，以加密解密速度快，实现简单著称。TEA算法每一次可以操作64bit(8byte)，采用128bit(16byte)作为key，算法采用迭代的形式，推荐的迭代轮数是64轮，最少32轮。为解决TEA算法密钥表攻击的问题，TEA算法先后经历了几次改进，从XTEA到BLOCK TEA，直至最新的XXTEA。XTEA也称做TEAN，它使用与TEA相同的简单运算，但四个子密钥采取不正规的方式进行混合以阻止密钥表攻击。Block TEA算法可以对32位的任意整数倍长度的变量块进行加解密的操作，该算法将XTEA轮循函数依次应用于块中的每个字，并且将它附加于被应用字的邻字。XXTEA使用跟Block TEA相似的结构，但在处理块中每个字时利用了相邻字，且用拥有两个输入量的MX函数代替了XTEA轮循函数。本文所描述的安全机制采用的加密算法就是TEA算法中安全性能最佳的改进版本－XXTEA算法。

XXTEA算法的结构非常简单，只需要执行加法、异或和寄存的硬件即可，且软件实现的代码非常短小，具有可移植性，非常适合嵌入式系统应用。由于XXTEA算法的以上优点，可以很好地应用于嵌入式RFID系统当中。

C语言实现:

#define MX (z>>5^y<<2) + (y>>3^z<<4)^(sum^y) + (k[p&3^e]^z);
 
 long btea(long* v, long n, long* k) {
   unsigned long z=v[n-1], y=v[0], sum=0, e, DELTA=0x9e3779b9;
   long p, q ;
   if (n > 1) {         
     q = 6 + 52/n;
     while (q-- > 0) {
       sum += DELTA;
       e = (sum >> 2) & 3;
       for (p=0; p<n-1; p++) y = v[p+1], z = v[p] += MX;
       y = v[0];
       z = v[n-1] += MX;
     }
     return 0 ;
   } else if (n < -1) { 
     n = -n;
     q = 6 + 52/n;
     sum = q*DELTA ;
     while (sum != 0) {
       e = (sum >> 2) & 3;
       for (p=n-1; p>0; p--) z = v[p-1], y = v[p] -= MX;
       z = v[n-1];
       y = v[0] -= MX;
       sum -= DELTA;
     }
     return 0;
   }
   return 1;
 }

   
Lua语言实现

---------------------------------------------------------------------
-- Author: Jørn Skaarud Karlsen
---------------------------------------------------------------------

require("bit")
require("hex")

---------------------------------------------------------------------
-- Constants
---------------------------------------------------------------------

delta = 0x9E3779B9

---------------------------------------------------------------------
-- Conversion
---------------------------------------------------------------------

function convertStringToBytes(str)
    local bytes = {}
    local strLength = string.len(str)
    for i=1,strLength do
        table.insert(bytes, string.byte(str, i))
    end

    return bytes
end

function convertBytesToString(bytes)
    local bytesLength = table.getn(bytes)
    local str = ""
    for i=1,bytesLength do
        str = str .. string.char(bytes[i])
    end

    return str
end

function convertHexStringToBytes(str)
    local bytes = {}
    local strLength = string.len(str)
    for k=2,strLength,2 do
        local hexString = "0x" .. string.sub(str, (k - 1), k)
        table.insert(bytes, hex.to_dec(hexString))
    end

    return bytes
end

function convertBytesToHexString(bytes)
    local str = ""
    local bytesLength = table.getn(bytes)
    for i=1,bytesLength do
        local hexString = string.sub(hex.to_hex(bytes[i]), 3)
        if string.len(hexString) == 1 then
            hexString = "0" .. hexString
        end
        str = str .. hexString
    end

    return str
end

function convertBytesToUIntArray(bytes, includeLength)
    local bytesLength = table.getn(bytes)
    local result = {}

    if includeLength then
        local n = bit.brshift(bytesLength, 2) + 1
        if bit.band(bytesLength, 3) ~= 0 then
            n = n + 1
        end

        result[n] = bytesLength;
    end

    for i=0,(bytesLength - 1) do
        local resultIndex = bit.brshift(i, 2) + 1
        if result[resultIndex] == nil then
            result[resultIndex] = 0
        end

        local resultValue = bit.blshift(bit.band(0x000000ff, bytes[i+1]), bit.blshift(bit.band(i, 3), 3))
        result[resultIndex] = bit.bor(result[resultIndex], resultValue);
    end

    return result
end

function convertUIntArrayToBytes(data, includeLength)
    local dataLength = table.getn(data)
    local n = bit.blshift(dataLength, 2)
    local result = {}

    if includeLength then
        local m = data[dataLength]
        if m > n then
            return nil
        end

        n = m
    end

    for i=0,(n-1) do
        local value = bit.band(bit.brshift(data[bit.brshift(i, 2) + 1], (bit.blshift(bit.band(i, 3), 3))), 0xff)
        table.insert(result, value)
    end

    return result
end

function convertToUInt32(value)
    if value < 0 then
        local absValue = math.abs(value)
        local a = math.floor(absValue / 0xFFFFFFFF)
        local b = value + a * 0xFFFFFFFF
        local c = 0xFFFFFFFF + b + 1
        return c
    end

    return math.mod(value, 0xFFFFFFFF) - math.floor(value / 0xFFFFFFFF)
end

---------------------------------------------------------------------
-- Encryption/decryption common
---------------------------------------------------------------------

function mx(sum, y, z, p, e, k)
    local aa = bit.brshift(z, 5)
    local ab = convertToUInt32(bit.blshift(y, 2))
    local ac = bit.bxor(aa, ab)

    local ba = bit.brshift(y, 3)
    local bb = convertToUInt32(bit.blshift(z, 4))
    local bc = bit.bxor(ba, bb)
    local ca = bit.bxor(sum, y)

    local dia = bit.band(p, 3)
    local dib = bit.bxor(dia, e)
    local da = k[dib + 1]
    local db = bit.bxor(da, z)

    local ea = convertToUInt32(ca + db)
    local fa = convertToUInt32(ac + bc)
    local ga = bit.bxor(fa, ea)

    return ga
end

---------------------------------------------------------------------
-- Decryption
---------------------------------------------------------------------

function decryptIntArray(v, k)
    local n = table.getn(v)
    local z = v[n]
    local y = v[1]
    local e = 0
    local p = 0

    local q = 6 + math.floor(52 / n)
    local sum = convertToUInt32(q * delta)
    while sum ~= 0 do
        e = bit.band(bit.brshift(sum, 2), 3)
        for p=n,2,-1 do
            z = v[p - 1]
            v[p] = convertToUInt32(v[p] - mx(sum, y, z, (p-1), e, k))
            y = v[p]
        end

        z = v[n]
        v[1] = convertToUInt32(v[1] - mx(sum, y, z, p, e, k))
        y = v[1]

        local sumBefore = sum
        sum = convertToUInt32(sum - delta)
    end

    return v
end

function decrypt(data, key)
    local dataLength = string.len(data)
    local keyLength = string.len(key)

    if keyLength == 0 then
        return data
    end

    local keyBytes = convertStringToBytes(key)
    local encryptedBytes = convertHexStringToBytes(data)

    local dataIntArray = convertBytesToUIntArray(encryptedBytes, false)
    local keyIntArray = convertBytesToUIntArray(keyBytes, false)

    local decryptedIntArray = decryptIntArray(dataIntArray, keyIntArray)
    local decryptedBytes = convertUIntArrayToBytes(decryptedIntArray, true)
    local decryptedString = convertBytesToString(decryptedBytes)

    return decryptedString
end

---------------------------------------------------------------------
-- Encryption
---------------------------------------------------------------------

function encryptIntArray(v, k)

    n = table.getn(v)
    if n < 2 then
        return v
    end

    local z = v[n]
    local y = v[1]
    local sum = 0
    local e = 0
    local p = 0
    local initQ = 6 + math.floor(52 / n)

    for q=initQ,1,-1 do
        sum = convertToUInt32(sum + delta);
        e = bit.band(bit.brshift(sum, 2), 3);
        for p=1,(n-1) do
            y = v[p + 1];
            v[p] = convertToUInt32(v[p] + mx(sum, y, z, (p-1), e, k));
            z = v[p]
        end
        y = v[1];
        v[n] = convertToUInt32(v[n] + mx(sum, y, z, (n-1), e, k));
        z = v[n]
    end

    return v;

end

function encrypt(data, key)
    local dataLength = string.len(data)
    local keyLength = string.len(key)

    if (keyLength == 0) then
        return data
    end

    local dataBytes = convertStringToBytes(data)
    local keyBytes = convertStringToBytes(key)

    local dataIntArray = convertBytesToUIntArray(dataBytes, true)
    local keyIntArray = convertBytesToUIntArray(keyBytes, false)

    local encryptedIntArray = encryptIntArray(dataIntArray, keyIntArray)
    local encryptedBytes = convertUIntArrayToBytes(encryptedIntArray, false)
    local encryptedString = convertBytesToHexString(encryptedBytes)

    return encryptedString
end

---------------------------------------------------------------------
-- Program: replace
---------------------------------------------------------------------

unencryptedInput = "This is a test"
encryptionKeyInput = "xxxxxxxxxxxxxxxxxxxx"   -- Place your encryption key here

encryptedOutput = encrypt(unencryptedInput, encryptionKeyInput)
print(encryptedOutput)

decryptedEncryptedOutput = decrypt(encryptedOutput, encryptionKeyInput)
print(decryptedEncryptedOutput)

AS3语言实现

/**********************************************************\
|                                                          |
| The implementation of PHPRPC Protocol 3.0                |
|                                                          |
| XXTEA.as                                                 |
|                                                          |
| Release 3.0.0                                            |
| Copyright (c) 2005-2007 by Team-PHPRPC                   |
|                                                          |
| WebSite:  http://www.phprpc.org/                         |
|           http://www.phprpc.net/                         |
|           http://www.phprpc.com/                         |
|           http://sourceforge.net/projects/php-rpc/       |
|                                                          |
| Authors:  Ma Bingyao <andot@ujn.edu.cn>                  |
|                                                          |
| This file may be distributed and/or modified under the   |
| terms of the GNU Lesser General Public License (LGPL)    |
| version 3.0 as published by the Free Software Foundation |
| and appearing in the included file LICENSE.              |
|                                                          |
\**********************************************************/
/* XXTEA encryption arithmetic library.
 *
 * Copyright (C) 2006-2007 Ma Bingyao <andot@ujn.edu.cn>
 * Version: 1.7
 * LastModified: Nov 5, 2007
 * This library is free.  You can redistribute it and/or modify it.
 */
 
package org.phprpc.util {
    import flash.utils.ByteArray;
    import flash.utils.Endian;
    public class XXTEA {
        private static const delta:uint = uint(0x9E3779B9);
        private static function LongArrayToByteArray(data:Array, includeLength:Boolean):ByteArray {
            var length:uint = data.length;
            var n:uint = (length - 1) << 2;
            if (includeLength) {
                var m:uint = data[length - 1];
                if ((m < n - 3) || (m > n)) {
                    return null;
                }
                n = m;
            }
            var result:ByteArray = new ByteArray();
            result.endian = Endian.LITTLE_ENDIAN;
            for (var i:uint = 0; i < length; i++) {
                result.writeUnsignedInt(data[i]);
            }
            if (includeLength) {
                result.length = n;
                return result;
            }
            else {
                return result;
            }
        }
        private static function ByteArrayToLongArray(data:ByteArray, includeLength:Boolean):Array {
            var length:uint = data.length;
            var n:uint = length >> 2;
            if (length % 4 > 0) {
                n++;
                data.length += (4 - (length % 4));
            }
            data.endian = Endian.LITTLE_ENDIAN;
            data.position = 0;
            var result:Array = [];
            for (var i:uint = 0; i < n; i++) {
                result[i] = data.readUnsignedInt();
            }
            if (includeLength) {
                result[n] = length;
            }
            data.length = length;
            return result;
        }
        public static function encrypt(data:ByteArray, key:ByteArray):ByteArray {
            if (data.length == 0) {
                return new ByteArray();
            }
            var v:Array = ByteArrayToLongArray(data, true);
            var k:Array = ByteArrayToLongArray(key, false);
            if (k.length < 4) {
                k.length = 4;
            }
            var n:uint = v.length - 1;
            var z:uint = v[n];
            var y:uint = v[0];
            var mx:uint;
            var e:uint;
            var p:uint;
            var q:uint = uint(6 + 52 / (n + 1));
            var sum:uint = 0;
            while (0 < q--) {
                sum = sum + delta;
                e = sum >>> 2 & 3;
                for (p = 0; p < n; p++) {
                    y = v[p + 1];
                    mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
                    z = v[p] = v[p] + mx;
                }
                y = v[0];
                mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
                z = v[n] = v[n] + mx;
            }
            return LongArrayToByteArray(v, false);
        }
        public static function decrypt(data:ByteArray, key:ByteArray):ByteArray {
            if (data.length == 0) {
                return new ByteArray();
            }
            var v:Array = ByteArrayToLongArray(data, false);
            var k:Array = ByteArrayToLongArray(key, false);
            if (k.length < 4) {
                k.length = 4;
            }
            var n:uint = v.length - 1;
            var z:uint = v[n - 1];
            var y:uint = v[0];
            var mx:uint;
            var e:uint;
            var p:uint;
            var q:uint = uint(6 + 52 / (n + 1));
            var sum:uint = q * delta;
            while (sum != 0) {
                e = sum >>> 2 & 3;
                for (p = n; p > 0; p--) {
                    z = v[p - 1];
                    mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
                    y = v[p] = v[p] - mx;
                }
                z = v[n];
                mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
                y = v[0] = v[0] - mx;
                sum = sum - delta;
            }
            return LongArrayToByteArray(v, true);
        }
    }
}

JS语言实现

/* XXTEA encryption arithmetic library.
*
* Copyright (C) 2006 Ma Bingyao <andot@ujn.edu.cn>
* Version:      1.5
* LastModified: Dec 9, 2006
* This library is free.  You can redistribute it and/or modify it.
*/
 
function long2str(v, w) {
    var vl = v.length;
    var n = (vl - 1) << 2;
    if (w) {
        var m = v[vl - 1];
        if ((m < n - 3) || (m > n)) return null;
        n = m;
    }
    for (var i = 0; i < vl; i++) {
        v[i] = String.fromCharCode(v[i] & 0xff,
                                   v[i] >>> 8 & 0xff,
                                   v[i] >>> 16 & 0xff,
                                   v[i] >>> 24 & 0xff);
    }
    if (w) {
        return v.join('').substring(0, n);
    }
    else {
        return v.join('');
    }
}
 
function str2long(s, w) {
    var len = s.length;
    var v = [];
    for (var i = 0; i < len; i += 4) {
        v[i >> 2] = s.charCodeAt(i)
                  | s.charCodeAt(i + 1) << 8
                  | s.charCodeAt(i + 2) << 16
                  | s.charCodeAt(i + 3) << 24;
    }
    if (w) {
        v[v.length] = len;
    }
    return v;
}
 
function xxtea_encrypt(str, key) {
    if (str == "") {
        return "";
    }
    var v = str2long(str, true);
    var k = str2long(key, false);
    if (k.length < 4) {
        k.length = 4;
    }
    var n = v.length - 1;
 
    var z = v[n], y = v[0], delta = 0x9E3779B9;
    var mx, e, p, q = Math.floor(6 + 52 / (n + 1)), sum = 0;
    while (0 < q--) {
        sum = sum + delta & 0xffffffff;
        e = sum >>> 2 & 3;
        for (p = 0; p < n; p++) {
            y = v[p + 1];
            mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
            z = v[p] = v[p] + mx & 0xffffffff;
        }
        y = v[0];
        mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
        z = v[n] = v[n] + mx & 0xffffffff;
    }
 
    return long2str(v, false);
}
 
function xxtea_decrypt(str, key) {
    if (str == "") {
        return "";
    }
    var v = str2long(str, false);
    var k = str2long(key, false);
    if (k.length < 4) {
        k.length = 4;
    }
    var n = v.length - 1;
 
    var z = v[n - 1], y = v[0], delta = 0x9E3779B9;
    var mx, e, p, q = Math.floor(6 + 52 / (n + 1)), sum = q * delta & 0xffffffff;
    while (sum != 0) {
        e = sum >>> 2 & 3;
        for (p = n; p > 0; p--) {
            z = v[p - 1];
            mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
            y = v[p] = v[p] - mx & 0xffffffff;
        }
        z = v[n];
        mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
        y = v[0] = v[0] - mx & 0xffffffff;
        sum = sum - delta & 0xffffffff;
    }
 
    return long2str(v, true);
}

PHP语言实现

<?php
/* XXTEA encryption arithmetic library.
*
* Copyright (C) 2006 Ma Bingyao <andot@ujn.edu.cn>
* Version:      1.5
* LastModified: Dec 5, 2006
* This library is free.  You can redistribute it and/or modify it.
*/
 
function long2str($v, $w) {
    $len = count($v);
    $n = ($len - 1) << 2;
    if ($w) {
        $m = $v[$len - 1];
        if (($m < $n - 3) || ($m > $n)) return false;
        $n = $m;
    }
    $s = array();
    for ($i = 0; $i < $len; $i++) {
        $s[$i] = pack("V", $v[$i]);
    }
    if ($w) {
        return substr(join('', $s), 0, $n);
    }
    else {
        return join('', $s);
    }
}
 
function str2long($s, $w) {
    $v = unpack("V*", $s. str_repeat("\0", (4 - strlen($s) % 4) & 3));
    $v = array_values($v);
    if ($w) {
        $v[count($v)] = strlen($s);
    }
    return $v;
}
 
function int32($n) {
    while ($n >= 2147483648) $n -= 4294967296;
    while ($n <= -2147483649) $n += 4294967296;
    return (int)$n;
}
 
function xxtea_encrypt($str, $key) {
    if ($str == "") {
        return "";
    }
    $v = str2long($str, true);
    $k = str2long($key, false);
    if (count($k) < 4) {
        for ($i = count($k); $i < 4; $i++) {
            $k[$i] = 0;
        }
    }
    $n = count($v) - 1;
 
    $z = $v[$n];
    $y = $v[0];
    $delta = 0x9E3779B9;
    $q = floor(6 + 52 / ($n + 1));
    $sum = 0;
    while (0 < $q--) {
        $sum = int32($sum + $delta);
        $e = $sum >> 2 & 3;
        for ($p = 0; $p < $n; $p++) {
            $y = $v[$p + 1];
            $mx = int32((($z >> 5 & 0x07ffffff) ^ $y << 2) + (($y >> 3 & 0x1fffffff) ^ $z << 4)) ^ int32(($sum ^ $y) + ($k[$p & 3 ^ $e] ^ $z));
            $z = $v[$p] = int32($v[$p] + $mx);
        }
        $y = $v[0];
        $mx = int32((($z >> 5 & 0x07ffffff) ^ $y << 2) + (($y >> 3 & 0x1fffffff) ^ $z << 4)) ^ int32(($sum ^ $y) + ($k[$p & 3 ^ $e] ^ $z));
        $z = $v[$n] = int32($v[$n] + $mx);
    }
    return long2str($v, false);
}
 
function xxtea_decrypt($str, $key) {
    if ($str == "") {
        return "";
    }
    $v = str2long($str, false);
    $k = str2long($key, false);
    if (count($k) < 4) {
        for ($i = count($k); $i < 4; $i++) {
            $k[$i] = 0;
        }
    }
    $n = count($v) - 1;
 
    $z = $v[$n];
    $y = $v[0];
    $delta = 0x9E3779B9;
    $q = floor(6 + 52 / ($n + 1));
    $sum = int32($q * $delta);
    while ($sum != 0) {
        $e = $sum >> 2 & 3;
        for ($p = $n; $p > 0; $p--) {
            $z = $v[$p - 1];
            $mx = int32((($z >> 5 & 0x07ffffff) ^ $y << 2) + (($y >> 3 & 0x1fffffff) ^ $z << 4)) ^ int32(($sum ^ $y) + ($k[$p & 3 ^ $e] ^ $z));
            $y = $v[$p] = int32($v[$p] - $mx);
        }
        $z = $v[$n];
        $mx = int32((($z >> 5 & 0x07ffffff) ^ $y << 2) + (($y >> 3 & 0x1fffffff) ^ $z << 4)) ^ int32(($sum ^ $y) + ($k[$p & 3 ^ $e] ^ $z));
        $y = $v[0] = int32($v[0] - $mx);
        $sum = int32($sum - $delta);
    }
    return long2str($v, true);
}
?>

时间： 2024-10-21 17:49:34

介绍XXTEA加密算法的相关文章

用ASP加密算法“保护”你的数据

加密|数据|算法     首先简单介绍一下有关加密的背景.由于美国禁止几种密码算法的对外出口的加密位数(例如SSL的40位加密限制),本文将介绍一种ASP可以使用的简单字符加密算法,而不是那些受限制的加密算法.其实,这里介绍的加密算法对于一般的运用来说已经足够解密人麻烦一阵子的了.它的加密基础是最简单的Vernum密码方法,我将在下一篇文章中介绍这种密码. 它的基本原理是,需要有一个需要加密的 明文和一个随机生成的解密钥匙文件.然后使用这两个文件组合起来生成密文. (明文) 组合 (密钥) =

使用ASP加密算法加密你的数据（一）

加密|数据|算法 简介 首先简单介绍一下有关加密的背景.由于美国禁止几种密码算法的对外出口的加密位数(例如SSL的40位加密限制),本文将介绍一种ASP可以使用的简单字符加密算法,而不是那些受限制的加密算法.其实,这里介绍的加密算法对于一般的运用来说已经足够解密人麻烦一阵子的了.它的加密基础是最简单的Vernum密码方法,我将在下一篇文章中介绍这种密码. 它的基本原理是,需要有一个需要加密的 明文和一个随机生成的解密钥匙文件.然后使用这两个文件组合起来生成密文. (明文) 组合 (密钥) = 加

使用ASP加密算法加密你的数据

使用ASP加密算法加密你的数据简介首先简单介绍一下有关加密的背景.由于美国禁止几种密码算法的对外出口的加密位数(例如SSL的40位加密限制),本文将介绍一种ASP可以使用的简单字符加密算法,而不是那些受限制的加密算法.其实,这里介绍的加密算法对于一般的运用来说已经足够解密人麻烦一阵子的了.它的加密基础是最简单的Vernum密码方法,我将在下一篇文章中介绍这种密码.它的基本原理是,需要有一个需要加密的明文和一个随机生成的解密钥匙文件.然后使用这两个文件组合起来生成密文.(明文) 组合 (密钥) =

Java加密技术（二）

接下来我们介绍对称加密算法,最常用的莫过于DES数据加密算法. DES DES-Data Encryption Standard,即数据加密算法.是IBM公司于1975年研究成功并公开发表的.DES算法的入口参数有三个:Key.Data.Mode.其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密. DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位. 通过java

漫谈iOS RSA非对称加密与解密

前言 最近公司的客户端安全性出现了严重的问题,如今这个出解决方案并自我测试验证可行性的重任落在了我的身上,学习了很多他人的文章,再经过多次讨论,最后才确定最终解决方案.笔者在这里讲讲这一经历中所需要了解的知识. iOS客户端想要加密传输数据以防被窃取,最可靠的方式莫过于使用公钥加密算法加密,使用HTTPS协议在整个传输过程中都使用了这个技术,对于未能使用HTTPS的HTTP接口,我们能否实现RSA加密呢? PHP端实现解密可参考:iOS与PHP端实现RSA非对称加密解密 提示:本篇文章只讲RSA

ECC加密算法入门介绍

加密|算法 ECC加密算法入门介绍 前言 同RSA(Ron Rivest,Adi Shamir,Len Adleman三位天才的名字)一样,ECC(Elliptic Curves Cryptography,椭圆曲线密码编码学)也属于公开密钥算法.目前,国内详细介绍ECC的公开文献并不多(反正我没有找到).有一些简介,也是泛泛而谈,看完后依然理解不了ECC的实质(可能我理解力太差).前些天我从国外网站找到些材料,看完后对ECC似乎懵懂了.于是我想把我对ECC的认识整理一下,与大家分享.当然ECC博

DES、AES、RSA等常用加密算法介绍与比较

       文本先简单介绍常用的加密算法,后面将逐步推送每个加密算法的加密原理与应用及java实现方式.        加密算法分对称加密和非对称算法,其中对称加密算法的加密与解密密钥相同,非对称加密算法的加密密钥与解密密钥不同,此外,还有一类不需要密钥的散列算法.        常见的对称加密算法主要有DES.3DES.AES等,常见的非对称算法主要有RSA.DSA等,散列算法主要有SHA-1.MD5等.        对称算法又可分为两类.一次只对明文中的单个位(有时对字节)运算的算法称为

iOS中MD5加密算法的介绍和使用_IOS

前言 软件开发过程中,对数据进行加密是保证数据安全的重要手段,常见的加密有Base64加密和MD5加密.Base64加密是可逆的,MD5加密目前来说一般是不可逆的. MD5生成的是固定的128bit,即128个0和1的二进制位,而在实际应用开发中,通常是以16进制输出的,所以正好就是32位的16进制,说白了也就是32个16进制的数字. MD5主要特点是 不可逆,相同数据的MD5值肯定一样,不同数据的MD5值不一样(也不是绝对的,但基本是不能一样的). MD5算法还具有以下性质:       1.

iOS常用加密算法介绍和代码实践_IOS

iOS系统库中定义了软件开发中常用的加解密算法,接口为C语言形式.具体包括了以下几个大类:  #include <CommonCrypto/CommonCryptor.h> //常用加解密算法 #include <CommonCrypto/CommonDigest.h> //摘要算法 #include <CommonCrypto/CommonHMAC.h> #include <CommonCrypto/CommonKeyDerivation.h> #incl