加密算法

C#可逆加密-Rijndael算法

CS文件：

Rijndael算法//App_Code

using System;

using System.IO;

using System.Security.Cryptography;

using System.Text;

 

namespace DataCrypto

{

    /**//// <summary>

    /// DataCrypto 的摘要说明

    /// </summary>

    public class SymmetricMethod

    {

        private SymmetricAlgorithm mobjCryptoService;

        private string Key;

        /**//// <summary>

        /// 对称加密类的构造函数

        /// </summary>

        public SymmetricMethod()

        {

            mobjCryptoService = new RijndaelManaged();

            Key = "lijianfufaicaixiaoke";

        }

        /**//// <summary>

        /// 获得密钥

        /// </summary>

        /// <returns>密钥</returns>

        private byte[] GetLegalKey()

        {

            string sTemp = Key;

            mobjCryptoService.GenerateKey();

            byte[] bytTemp = mobjCryptoService.Key;

            int KeyLength = bytTemp.Length;

            if (sTemp.Length > KeyLength)

                sTemp = sTemp.Substring(0, KeyLength);

            else if (sTemp.Length < KeyLength)

                sTemp = sTemp.PadRight(KeyLength, ' ');

            return ASCIIEncoding.ASCII.GetBytes(sTemp);

        }

        /**//// <summary>

        /// 获得初始向量IV

        /// </summary>

        /// <returns>初试向量IV</returns>

        private byte[] GetLegalIV()

        {

            string sTemp = "caoxiaokeailijianfu";

            mobjCryptoService.GenerateIV();

            byte[] bytTemp = mobjCryptoService.IV;

            int IVLength = bytTemp.Length;

            if (sTemp.Length > IVLength)

                sTemp = sTemp.Substring(0, IVLength);

            else if (sTemp.Length < IVLength)

                sTemp = sTemp.PadRight(IVLength, ' ');

            return ASCIIEncoding.ASCII.GetBytes(sTemp);

        }

        /**//// <summary>

        /// 加密方法

        /// </summary>

        /// <param name="Source">待加密的串</param>

        /// <returns>经过加密的串</returns>

        public string Encrypto(string Source)

        {

            byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);

            MemoryStream ms = new MemoryStream();

            mobjCryptoService.Key = GetLegalKey();

            mobjCryptoService.IV = GetLegalIV();

            ICryptoTransform encrypto = mobjCryptoService.CreateEncryptor();

            CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);

            cs.Write(bytIn, 0, bytIn.Length);

            cs.FlushFinalBlock();

            ms.Close();

            byte[] bytOut = ms.ToArray();

            return Convert.ToBase64String(bytOut);

        }

        /**//// <summary>

        /// 解密方法

        /// </summary>

        /// <param name="Source">待解密的串</param>

        /// <returns>经过解密的串</returns>

        public string Decrypto(string Source)

        {

            byte[] bytIn = Convert.FromBase64String(Source);

            MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);

            mobjCryptoService.Key = GetLegalKey();

            mobjCryptoService.IV = GetLegalIV();

            ICryptoTransform encrypto = mobjCryptoService.CreateDecryptor();

            CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);

            StreamReader sr = new StreamReader(cs);

            return sr.ReadToEnd();

        }

    }

}前台显示：    protected void Page_Load(object sender, EventArgs e)

    {

        DataCrypto.SymmetricMethod sm = new DataCrypto.SymmetricMethod();

        string a = sm.Encrypto("asdf").ToString().Trim();

        string b = sm.Decrypto(a).ToString();

        Response.Write(a+"<br>"+b);

    }

最安全的加密算法

 

在密码学里，有一种理想的加密方案，叫做一次一密乱码本（one-time pad）。one-time pad的算法有以下要求：1、密钥必须随机产生2、密钥不能重复使用3、密钥和密文的长度是一样的。one-time pad是最安全的加密算法，双方一旦安全交换了密钥，之后交换信息的过程就是绝对安全的啦。这种算法一直在一些要求高度机密的场合使用，据说美国和前苏联之间的热线电话、前苏联的间谍都是使用One-time pad的方式加密的。不管超级计算机工作多久，也不管多少人，用什么方法和技术，具有多大的计算能力，都不可能破解。一次一密的一种实现方式，如下：

public class .NetimePadUtil

{   

public static byte[] xor(byte[] bytes, byte[] keyBytes)

{       

if (keyBytes.length != bytes.length)

{           

throw new IllegalArgumentException();       

}       

byte[] resultBytes = new byte[bytes.length];    

for (int i = 0; i < resultBytes.length; ++i)

{           

resultBytes[i] = (byte) (keyBytes[i] ^ bytes[i]);       

}       

return resultBytes;   

}

}

使用例子：

String plainText = "温少";

String keyText = "密码";

byte[] plainBytes = plainText.getBytes();

byte[] keyBytes = keyText.getBytes();

assert plainBytes.length == keyBytes.length;//加密

byte[] cipherBytes = .NetimePadUtil.xor(plainBytes, keyBytes);//解密

byte[] cipherPlainBytes = .NetimePadUtil.xor(cipherBytes, keyBytes);

这是最简单的加密算法，但也是最安全的机密算法。前天和朋友讨论到了这个问题，所以写了这篇文章。

该文章转载自网络大本营：http://www.xrss.cn/Dev/MD5/2006663201.Html

 

银行家算法

 

银行家算法是一种最有代表性的避免死锁的算法。

要解释银行家算法，必须先解释操作系统安全状态和不安全状态。

安全状态：如果存在一个由系统中所有进程构成的安全序列P1，…，Pn，则系统处于安全状态。安全状态一定是没有死锁发生。

不安全状态:不存在一个安全序列。不安全状态一定导致死锁。

那么什么是安全序列呢？

安全序列：一个进程序列{P1，…，Pn}是安全的，如果对于每一个进程Pi(1≤i≤n），它以后尚需要的资源量不超过系统当前剩余资源量与所有进程Pj (j < i )当前占有资源量之和。

银行家算法：

我们可以把操作系统看作是银行家，操作系统管理的资源相当于银行家管理的资金，进程向操作系统请求分配资源相当于用户向银行家贷款。操作系统按照银行家制定的规则为进程分配资源，当进程首次申请资源时，要测试该进程对资源的最大需求量，如果系统现存的资源可以满足它的最大需求量则按当前的申请量分配资源，否则就推迟分配。当进程在执行中继续申请资源时，先测试该进程已占用的资源数与本次申请的资源数之和是否超过了该进程对资源的最大需求量。若超过则拒绝分配资源，若没有超过则再测试系统现存的资源能否满足该进程尚需的最大资源量，若能满足则按当前的申请量分配资源，否则也要推迟分配。

算法：

n：系统中进程的总数

m：资源类总数

Available:

ARRAY[1..m] of integer;

Max:

ARRAY[1..n,1..m] of integer;

Allocation:

ARRAY[1..n,1..m] of integer;

Need:

ARRAY[1..n,1..m] of integer;

Request:

ARRAY[1..n,1..m] of integer;

简记符号：

Available

Max[i]

Allocation[i]

Need[i]

Request[i]

当进程pi提出资源申请时，系统执行下列

步骤：

（1）若Request[i]≤Need[i],转（2）；

否则错误返回

（2）若Request[i]≤Available,

转（3）；否则进程等待

(3）假设系统分配了资源，则有：

Available:=Available-Request[i];

Allocation[i]:=

Allocation[i]+Request[i];

Need[i]:=Need[i]-Request[i]

若系统新状态是安全的，则分配完成

若系统新状态是不安全的，则恢复原状态，进程等待

为进行安全性检查，定义数据结构：

Work:ARRAY[1..m] of integer;

Finish:ARRAY[1..n] of Boolean;

安全性检查的步骤：

(1) Work:=Available;

Finish:=false;

(2) 寻找满足条件的i：

a.Finish[i]=false;

b.Need[i]≤Work;

如果不存在，则转(4)

(3) Work:=Work+Allocation[i];

Finish[i]:=true;

转(2)

(4) 若对所有i,Finish[i]=true,则系

统处于安全状态，否则处于不安全状态