source: trunk/CrypPlugins/KeyPatternJob/KeyPatternJobPart.cs @ 1448

Last change on this file since 1448 was 1448, checked in by Sven Rech, 12 years ago

replaced all BigInteger stuff with the new BigInteger class from .net 4.0

But there are still problems with some plugins (Keysearcher, BigInteger Operations...)

File size: 10.1 KB
Line 
1/* Copyright 2010 Team CrypTool (Christian Arnold), Uni Duisburg-Essen
2
3   Licensed under the Apache License, Version 2.0 (the "License");
4   you may not use this file except in compliance with the License.
5   You may obtain a copy of the License at
6
7       http://www.apache.org/licenses/LICENSE-2.0
8
9   Unless required by applicable law or agreed to in writing, software
10   distributed under the License is distributed on an "AS IS" BASIS,
11   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12   See the License for the specific language governing permissions and
13   limitations under the License.
14*/
15
16using System;
17using System.Collections.Generic;
18using System.Linq;
19using System.Text;
20using Cryptool.Plugins.PeerToPeer.Jobs;
21using KeySearcher;
22using System.IO;
23using Cryptool.PluginBase.Miscellaneous;
24using System.Numerics;
25
26/*
27 * TODO:
28 * - At present to similar methods (byte[] constructor and Deserialize)
29 */
30
31namespace Cryptool.Plugins.PeerToPeer.Jobs
32{
33    public class KeyPatternJobPart : IJobPart
34    {
35        #region Properties and Variables
36
37        private BigInteger jobId;
38        public BigInteger JobId
39        {
40            get { return this.jobId ; }
41            set { this.jobId = value; }
42        }
43
44        private KeyPattern pattern;
45        public KeyPattern Pattern
46        {
47            get { return this.pattern; }
48            private set 
49            {
50                if (KeyPattern.testPattern(value.GetPattern()))
51                    this.pattern = value;
52                else
53                    throw (new Exception("KeyPattern isn't valid"));
54            }
55        }
56        private byte[] encryptData;
57        public byte[] EncryptData
58        {
59            get { return this.encryptData;}
60            private set { this.encryptData = value; }
61        }
62        private byte[] initVector;
63        public byte[] InitVector
64        {
65            get { return this.initVector; }
66            private set { this.initVector = value; }
67        }
68
69        #endregion
70
71        /// <summary>
72        /// standard constructor
73        /// </summary>
74        /// <param name="jobId">a unique jobId</param>
75        /// <param name="pattern">a valid KeyPattern</param>
76        /// <param name="encryptData">serialized encryptedData</param>
77        /// <param name="initVector">serialized initVector</param>
78        public KeyPatternJobPart(BigInteger jobId, KeyPattern pattern, byte[] encryptData, byte[] initVector)
79        {
80            this.JobId = jobId;
81            this.Pattern = pattern;
82            this.EncryptData = encryptData;
83            this.InitVector = initVector;
84        }
85
86        public KeyPatternJobPart(byte[] serializedKeyPatternJobPart)
87        {
88            /* So i always have the same byte length for int32 values */
89            int iTest = 500;
90            int int32ByteLen = BitConverter.GetBytes(iTest).Length;
91
92            MemoryStream memStream = new MemoryStream(serializedKeyPatternJobPart);
93            try
94            {
95                byte[] intBuffer = new byte[int32ByteLen];
96                // deserialize JobId
97                memStream.Read(intBuffer, 0, intBuffer.Length);
98                byte[] jobIdByte = new byte[BitConverter.ToInt32(intBuffer, 0)];
99                memStream.Read(jobIdByte, 0, jobIdByte.Length);
100                BigInteger temp_jobId = new BigInteger(jobIdByte);
101               
102                // deserialize KeyPattern
103                memStream.Read(intBuffer, 0, intBuffer.Length);
104                int byteLen = BitConverter.ToInt32(intBuffer, 0);
105                byte[] temp_serializedPattern = new byte[byteLen];
106                memStream.Read(temp_serializedPattern, 0, temp_serializedPattern.Length);
107                KeyPattern temp_pattern = new KeyPattern(temp_serializedPattern);
108
109                // deserialize EncryptData
110                memStream.Read(intBuffer, 0, intBuffer.Length);
111                byteLen = BitConverter.ToInt32(intBuffer, 0);
112                byte[] temp_encryptedData = new byte[byteLen];
113                memStream.Read(temp_encryptedData, 0, temp_encryptedData.Length);
114
115                // deserialize InitVector
116                memStream.Read(intBuffer, 0, intBuffer.Length);
117                byteLen = BitConverter.ToInt32(intBuffer, 0);
118                byte[] temp_initVector = new byte[byteLen];
119                memStream.Read(temp_initVector, 0, temp_initVector.Length);
120
121                //return new KeyPatternJobPart(temp_jobId, temp_pattern, temp_encryptedData, temp_initVector);
122                this.JobId = temp_jobId;
123                this.Pattern = temp_pattern;
124                this.EncryptData = temp_encryptedData;
125                this.InitVector = temp_initVector;
126            }
127            catch (Exception ex)
128            {
129                throw ex;
130            }
131            finally
132            {
133                memStream.Flush();
134                memStream.Close();
135                memStream.Dispose();
136            }
137        }
138
139        #region IJobPart<KeyPattern> Members
140
141        public KeyPatternJobPart Job()
142        {
143            return this;
144        }
145
146        public bool IsDivisable()
147        {
148            throw new NotImplementedException();
149        }
150
151        /* 4 Bytes: Length of serializedPattern
152         * x Bytes: serialized Pattern
153         * 4 Bytes: Length of encrypted Data
154         * x Bytes: encrypted Data
155         * 4 Bytes: Length of initialization value
156         * x Bytes: initialization value */
157        public byte[] Serialize()
158        {
159            MemoryStream memStream = new MemoryStream();
160            try
161            {
162                // serialize JobId
163                byte[] byteJobId = this.JobId.ToByteArray();
164                byte[] jobIdLen = BitConverter.GetBytes(byteJobId.Length);
165                memStream.Write(jobIdLen, 0, jobIdLen.Length);
166                memStream.Write(byteJobId, 0, byteJobId.Length);
167
168                // serialize KeyPattern
169                byte[] serializedPattern = this.Pattern.Serialize();
170                byte[] serializedPatternLen = BitConverter.GetBytes(serializedPattern.Length);
171                memStream.Write(serializedPatternLen, 0, serializedPatternLen.Length);
172                memStream.Write(serializedPattern, 0, serializedPattern.Length);
173
174                // serialize EncryptData
175                byte[] encryptDataLen = BitConverter.GetBytes(this.EncryptData.Length);
176                memStream.Write(encryptDataLen, 0, encryptDataLen.Length);
177                memStream.Write(this.EncryptData, 0, this.EncryptData.Length);
178
179                // serialize InitVector
180                byte[] initValueLen = BitConverter.GetBytes(this.InitVector.Length);
181                memStream.Write(initValueLen, 0, initValueLen.Length);
182                memStream.Write(this.InitVector, 0, this.InitVector.Length);
183
184                return memStream.ToArray();
185            }
186            catch (Exception ex)
187            {
188                throw ex;
189            }
190            finally
191            {
192                memStream.Flush();
193                memStream.Close();
194                memStream.Dispose();
195            }
196            return null;
197        }
198
199        /* This method have to be static, so I can call it without creating an "test instance" before */
200        /// <summary>
201        /// Deserializes a valid byte[] representation of the KeyPatternJobPart class
202        /// </summary>
203        /// <param name="serializedKeyPatternJobPart">a valid byte[] representation of the KeyPatternJobPart class</param>
204        /// <returns>a new KeyPatternJobPart instance</returns>
205        public static KeyPatternJobPart Deserialize(byte[] serializedKeyPatternJobPart)
206        {
207            return new KeyPatternJobPart(serializedKeyPatternJobPart);
208        }
209
210        ///* 4 Bytes: Length of serializedPattern
211        // * x Bytes: serialized Pattern
212        // * 4 Bytes: Length of encrypted Data
213        // * x Bytes: encrypted Data
214        // * 4 Bytes: Length of initialization value
215        // * x Bytes: initialization value */
216        //public KeyPatternJobPart Deserialize(byte[] serializedJobPart)
217        //{
218        //    MemoryStream memStream = new MemoryStream(serializedJobPart);
219        //    try
220        //    {
221        //        byte[] intBuffer = new byte[int32ByteLen];
222        //        // deserialize JobId
223        //        memStream.Read(intBuffer, 0, intBuffer.Length);
224        //        int temp_jobId = BitConverter.ToInt32(intBuffer);
225
226        //        // deserialize KeyPattern
227        //        memStream.Read(intBuffer, 0, intBuffer.Length);
228        //        int byteLen = BitConverter.ToInt32(intBuffer, 0);
229        //        byte[] temp_serializedPattern = new byte[byteLen];
230        //        memStream.Read(temp_serializedPattern, 0, temp_serializedPattern.Length);
231        //        KeyPattern temp_pattern = this.Pattern.Deserialize(temp_serializedPattern);
232
233        //        // deserialize EncryptData
234        //        memStream.Read(intBuffer, 0, intBuffer.Length);
235        //        byteLen = BitConverter.ToInt32(intBuffer, 0);
236        //        byte[] temp_encryptedData = new byte[byteLen];
237        //        memStream.Read(temp_encryptedData, 0, temp_encryptedData.Length);
238
239        //        // deserialize InitVector
240        //        memStream.Read(intBuffer, 0, intBuffer.Length);
241        //        byteLen = BitConverter.ToInt32(intBuffer, 0);
242        //        byte[] temp_initVector = new byte[byteLen];
243        //        memStream.Read(temp_initVector, 0, temp_initVector.Length);
244
245        //        return new KeyPatternJobPart(temp_jobId, temp_pattern, temp_encryptedData, temp_initVector);
246        //    }
247        //    catch (Exception ex)
248        //    {
249        //        throw ex;
250        //    }
251        //    finally
252        //    {
253        //        memStream.Flush();
254        //        memStream.Close();
255        //        memStream.Dispose();
256        //    }
257        //    return null;
258        //}
259
260        #endregion
261    }
262}
Note: See TracBrowser for help on using the repository browser.