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

Last change on this file since 1137 was 1137, checked in by arnold, 12 years ago

Completely redesigned Manager-JobAdmin-Worker-infrastructure to distribute Jobs with a Peer-to-Peer infrastructure to remote CT2-Workspaces.

To test this infrastructure, open 2 instances of CT and load P2P_Manager_NEW_DES.cte and in the other instance P2P_Worker_NEW.cte.
HINT: Working with remote peers isn't possible every time, because the so called "SuperNode", which is necessary for relaying, sometimes goes down. But testing this infrastructure on different computers in the same network should work every time.

File size: 10.0 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;
24
25/*
26 * TODO:
27 * - At present to similar methods (byte[] constructor and Deserialize)
28 */
29
30namespace Cryptool.Plugins.PeerToPeer.Jobs
31{
32    public class KeyPatternJobPart : IJobPart
33    {
34        #region Properties and Variables
35
36        private BigInteger jobId;
37        public BigInteger JobId
38        {
39            get { return this.jobId ; }
40            set { this.jobId = value; }
41        }
42
43        private KeyPattern pattern;
44        public KeyPattern Pattern
45        {
46            get { return this.pattern; }
47            private set 
48            {
49                if (KeyPattern.testPattern(value.GetPattern()))
50                    this.pattern = value;
51                else
52                    throw (new Exception("KeyPattern isn't valid"));
53            }
54        }
55        private byte[] encryptData;
56        public byte[] EncryptData
57        {
58            get { return this.encryptData;}
59            private set { this.encryptData = value; }
60        }
61        private byte[] initVector;
62        public byte[] InitVector
63        {
64            get { return this.initVector; }
65            private set { this.initVector = value; }
66        }
67
68        #endregion
69
70        /// <summary>
71        /// standard constructor
72        /// </summary>
73        /// <param name="jobId">a unique jobId</param>
74        /// <param name="pattern">a valid KeyPattern</param>
75        /// <param name="encryptData">serialized encryptedData</param>
76        /// <param name="initVector">serialized initVector</param>
77        public KeyPatternJobPart(BigInteger jobId, KeyPattern pattern, byte[] encryptData, byte[] initVector)
78        {
79            this.JobId = jobId;
80            this.Pattern = pattern;
81            this.EncryptData = encryptData;
82            this.InitVector = initVector;
83        }
84
85        public KeyPatternJobPart(byte[] serializedKeyPatternJobPart)
86        {
87            /* So i always have the same byte length for int32 values */
88            int iTest = 500;
89            int int32ByteLen = BitConverter.GetBytes(iTest).Length;
90
91            MemoryStream memStream = new MemoryStream(serializedKeyPatternJobPart);
92            try
93            {
94                byte[] intBuffer = new byte[int32ByteLen];
95                // deserialize JobId
96                memStream.Read(intBuffer, 0, intBuffer.Length);
97                byte[] jobIdByte = new byte[BitConverter.ToInt32(intBuffer, 0)];
98                memStream.Read(jobIdByte, 0, jobIdByte.Length);
99                BigInteger temp_jobId = new BigInteger(jobIdByte, jobIdByte.Length);
100               
101                // deserialize KeyPattern
102                memStream.Read(intBuffer, 0, intBuffer.Length);
103                int byteLen = BitConverter.ToInt32(intBuffer, 0);
104                byte[] temp_serializedPattern = new byte[byteLen];
105                memStream.Read(temp_serializedPattern, 0, temp_serializedPattern.Length);
106                KeyPattern temp_pattern = new KeyPattern(temp_serializedPattern);
107
108                // deserialize EncryptData
109                memStream.Read(intBuffer, 0, intBuffer.Length);
110                byteLen = BitConverter.ToInt32(intBuffer, 0);
111                byte[] temp_encryptedData = new byte[byteLen];
112                memStream.Read(temp_encryptedData, 0, temp_encryptedData.Length);
113
114                // deserialize InitVector
115                memStream.Read(intBuffer, 0, intBuffer.Length);
116                byteLen = BitConverter.ToInt32(intBuffer, 0);
117                byte[] temp_initVector = new byte[byteLen];
118                memStream.Read(temp_initVector, 0, temp_initVector.Length);
119
120                //return new KeyPatternJobPart(temp_jobId, temp_pattern, temp_encryptedData, temp_initVector);
121                this.JobId = temp_jobId;
122                this.Pattern = temp_pattern;
123                this.EncryptData = temp_encryptedData;
124                this.InitVector = temp_initVector;
125            }
126            catch (Exception ex)
127            {
128                throw ex;
129            }
130            finally
131            {
132                memStream.Flush();
133                memStream.Close();
134                memStream.Dispose();
135            }
136        }
137
138        #region IJobPart<KeyPattern> Members
139
140        public KeyPatternJobPart Job()
141        {
142            return this;
143        }
144
145        public bool IsDivisable()
146        {
147            throw new NotImplementedException();
148        }
149
150        /* 4 Bytes: Length of serializedPattern
151         * x Bytes: serialized Pattern
152         * 4 Bytes: Length of encrypted Data
153         * x Bytes: encrypted Data
154         * 4 Bytes: Length of initialization value
155         * x Bytes: initialization value */
156        public byte[] Serialize()
157        {
158            MemoryStream memStream = new MemoryStream();
159            try
160            {
161                // serialize JobId
162                byte[] byteJobId = this.JobId.getBytes();
163                byte[] jobIdLen = BitConverter.GetBytes(byteJobId.Length);
164                memStream.Write(jobIdLen, 0, jobIdLen.Length);
165                memStream.Write(byteJobId, 0, byteJobId.Length);
166
167                // serialize KeyPattern
168                byte[] serializedPattern = this.Pattern.Serialize();
169                byte[] serializedPatternLen = BitConverter.GetBytes(serializedPattern.Length);
170                memStream.Write(serializedPatternLen, 0, serializedPatternLen.Length);
171                memStream.Write(serializedPattern, 0, serializedPattern.Length);
172
173                // serialize EncryptData
174                byte[] encryptDataLen = BitConverter.GetBytes(this.EncryptData.Length);
175                memStream.Write(encryptDataLen, 0, encryptDataLen.Length);
176                memStream.Write(this.EncryptData, 0, this.EncryptData.Length);
177
178                // serialize InitVector
179                byte[] initValueLen = BitConverter.GetBytes(this.InitVector.Length);
180                memStream.Write(initValueLen, 0, initValueLen.Length);
181                memStream.Write(this.InitVector, 0, this.InitVector.Length);
182
183                return memStream.ToArray();
184            }
185            catch (Exception ex)
186            {
187                throw ex;
188            }
189            finally
190            {
191                memStream.Flush();
192                memStream.Close();
193                memStream.Dispose();
194            }
195            return null;
196        }
197
198        /* This method have to be static, so I can call it without creating an "test instance" before */
199        /// <summary>
200        /// Deserializes a valid byte[] representation of the KeyPatternJobPart class
201        /// </summary>
202        /// <param name="serializedKeyPatternJobPart">a valid byte[] representation of the KeyPatternJobPart class</param>
203        /// <returns>a new KeyPatternJobPart instance</returns>
204        public static KeyPatternJobPart Deserialize(byte[] serializedKeyPatternJobPart)
205        {
206            return new KeyPatternJobPart(serializedKeyPatternJobPart);
207        }
208
209        ///* 4 Bytes: Length of serializedPattern
210        // * x Bytes: serialized Pattern
211        // * 4 Bytes: Length of encrypted Data
212        // * x Bytes: encrypted Data
213        // * 4 Bytes: Length of initialization value
214        // * x Bytes: initialization value */
215        //public KeyPatternJobPart Deserialize(byte[] serializedJobPart)
216        //{
217        //    MemoryStream memStream = new MemoryStream(serializedJobPart);
218        //    try
219        //    {
220        //        byte[] intBuffer = new byte[int32ByteLen];
221        //        // deserialize JobId
222        //        memStream.Read(intBuffer, 0, intBuffer.Length);
223        //        int temp_jobId = BitConverter.ToInt32(intBuffer);
224
225        //        // deserialize KeyPattern
226        //        memStream.Read(intBuffer, 0, intBuffer.Length);
227        //        int byteLen = BitConverter.ToInt32(intBuffer, 0);
228        //        byte[] temp_serializedPattern = new byte[byteLen];
229        //        memStream.Read(temp_serializedPattern, 0, temp_serializedPattern.Length);
230        //        KeyPattern temp_pattern = this.Pattern.Deserialize(temp_serializedPattern);
231
232        //        // deserialize EncryptData
233        //        memStream.Read(intBuffer, 0, intBuffer.Length);
234        //        byteLen = BitConverter.ToInt32(intBuffer, 0);
235        //        byte[] temp_encryptedData = new byte[byteLen];
236        //        memStream.Read(temp_encryptedData, 0, temp_encryptedData.Length);
237
238        //        // deserialize InitVector
239        //        memStream.Read(intBuffer, 0, intBuffer.Length);
240        //        byteLen = BitConverter.ToInt32(intBuffer, 0);
241        //        byte[] temp_initVector = new byte[byteLen];
242        //        memStream.Read(temp_initVector, 0, temp_initVector.Length);
243
244        //        return new KeyPatternJobPart(temp_jobId, temp_pattern, temp_encryptedData, temp_initVector);
245        //    }
246        //    catch (Exception ex)
247        //    {
248        //        throw ex;
249        //    }
250        //    finally
251        //    {
252        //        memStream.Flush();
253        //        memStream.Close();
254        //        memStream.Dispose();
255        //    }
256        //    return null;
257        //}
258
259        #endregion
260    }
261}
Note: See TracBrowser for help on using the repository browser.