msnCommands.cs
1 using System;
2 using System.Diagnostics;
3 using System.Globalization;
4 using System.Text;
5 using MS.StrongName;
6
7 namespace MS.StrongName.ManagedSN
8 {
9 /// <summary>
10 /// Handler for each of the commands that the managed strong name tool implements
11 /// </summary>
12 internal static class Commands
13 {
14 /// <summary>
15 /// Delete a key pair from a key container (-d)
16 /// </summary>
17 /// <remarks>
18 /// Expects one argument, the key container name
19 /// </remarks>
20 /// <returns>SuccessCode if the key was removed, ErrorCode otherwise</returns>
21 public static int DeleteKeyPair(string[] arguments)
22 {
23 Debug.Assert(arguments != null, "Null arguments");
24
25 if(arguments.Length != 2)
26 {
27 Help(arguments);
28 return ManagedStrongName.ErrorCode;
29 }
30
31 Debug.Assert(arguments[0].EndsWith("d"));
32
33 // parse the arguments
34 string keyContainer = arguments[1];
35 if(String.IsNullOrEmpty(keyContainer) || String.IsNullOrEmpty(keyContainer.Trim()))
36 {
37 Log.Error(String.Format(
38 CultureInfo.CurrentCulture,
39 Resources.BadKeyContainer,
40 keyContainer));
41 return ManagedStrongName.ErrorCode;
42 }
43
44 // remove the key container
45 try
46 {
47 Keys.Delete(keyContainer);
48 }
49 catch(InvalidOperationException e)
50 {
51 Log.Error(String.Format(
52 CultureInfo.CurrentCulture,
53 Resources.BadOperation,
54 e.Message));
55 return ManagedStrongName.ErrorCode;
56 }
57
58 Log.Message(String.Format(
59 CultureInfo.CurrentCulture,
60 Resources.KeyContainerDeleted,
61 keyContainer));
62 return ManagedStrongName.SuccessCode;
63 }
64
65 /// <summary>
66 /// Display the public key token of an assembly (-T)
67 /// </summary>
68 /// <remarks>
69 /// Expects one argument, the assembly to get the token of
70 /// </remarks>
71 /// <returns>SuccessCode if the token was displayed properly, ErrorCode otherwise</returns>
72 public static int DisplayPublicKeyTokenFromAssembly(string[] arguments)
73 {
74 Debug.Assert(arguments != null, "Null arguments");
75
76 if(arguments.Length != 2)
77 {
78 Help(arguments);
79 return ManagedStrongName.ErrorCode;
80 }
81
82 Debug.Assert(arguments[0].EndsWith("T"));
83
84 // parse the arguments
85 string assembly = arguments[1];
86 if(String.IsNullOrEmpty(assembly))
87 {
88 Log.Error(String.Format(
89 CultureInfo.CurrentCulture,
90 Resources.BadFile,
91 String.Empty));
92 return ManagedStrongName.ErrorCode;
93 }
94
95 return DisplayPublicKeyTokenFromAssembly(assembly, false);
96 }
97
98 /// <summary>
99 /// Display the public key token and public key of an assembly (-Tp)
100 /// </summary>
101 /// <remarks>
102 /// Expects one argument, the assembly to get the token of
103 /// </remarks>
104 /// <returns>SuccessCode if the token was displayed properly, ErrorCode otherwise</returns>
105 public static int DisplayPublicKeyTokenWithKeyFromAssembly(string[] arguments)
106 {
107 Debug.Assert(arguments != null, "Null arguments");
108
109 if(arguments.Length != 2)
110 {
111 Help(arguments);
112 return ManagedStrongName.ErrorCode;
113 }
114
115 Debug.Assert(arguments[0].EndsWith("Tp"));
116
117 // parse the arguments
118 string assembly = arguments[1];
119 if(String.IsNullOrEmpty(assembly))
120 {
121 Log.Error(String.Format(
122 CultureInfo.CurrentCulture,
123 Resources.BadFile,
124 String.Empty));
125 return ManagedStrongName.ErrorCode;
126 }
127
128 return DisplayPublicKeyTokenFromAssembly(assembly, true);
129 }
130
131 /// <summary>
132 /// Display the public key token of a file (-t)
133 /// </summary>
134 /// <remarks>
135 /// Expects one argument, the public key to get the token of
136 /// </remarks>
137 /// <returns>SuccessCode if the token was displayed properly, ErrorCode otherwise</returns>
138 public static int DisplayPublicKeyTokenFromFile(string[] arguments)
139 {
140 Debug.Assert(arguments != null, "Null arguments");
141
142 if(arguments.Length != 2)
143 {
144 Help(arguments);
145 return ManagedStrongName.ErrorCode;
146 }
147
148 Debug.Assert(arguments[0].EndsWith("t"));
149
150 // parse the arguments
151 string publicKeyFile = arguments[1];
152 if(String.IsNullOrEmpty(publicKeyFile))
153 {
154 Log.Error(String.Format(
155 CultureInfo.CurrentCulture,
156 Resources.BadFile,
157 String.Empty));
158 return ManagedStrongName.ErrorCode;
159 }
160
161 return DisplayPublicKeyTokenFromFile(publicKeyFile, false);
162 }
163
164 /// <summary>
165 /// Display the public key token of a file along with the key (-tp)
166 /// </summary>
167 /// <remarks>
168 /// Expects one argument, the public key to get the token of
169 /// </remarks>
170 /// <returns>SuccessCode if the token was displayed properly, ErrorCode otherwise</returns>
171 public static int DisplayPublicKeyTokenWithKeyFromFile(string[] arguments)
172 {
173 Debug.Assert(arguments != null, "Null arguments");
174
175 if(arguments.Length != 2)
176 {
177 Help(arguments);
178 return ManagedStrongName.ErrorCode;
179 }
180
181 Debug.Assert(arguments[0].EndsWith("tp"));
182
183 // parse the arguments
184 string publicKeyFile = arguments[1];
185 if(String.IsNullOrEmpty(publicKeyFile))
186 {
187 Log.Error(String.Format(
188 CultureInfo.CurrentCulture,
189 Resources.BadFile,
190 String.Empty));
191 return ManagedStrongName.ErrorCode;
192 }
193
194 return DisplayPublicKeyTokenFromFile(publicKeyFile, true);
195 }
196
197 /// <summary>
198 /// Extract the public key from an assembly (-e)
199 /// </summary>
200 /// <remarks>
201 /// Expects two arguments, the assembly and the file to write into
202 /// </remarks>
203 /// <returns>SuccessCode if the key was extracted properly, ErrorCode otherwise</returns>
204 public static int ExtractAssemblyPublicKey(string[] arguments)
205 {
206 Debug.Assert(arguments != null, "Null arguments");
207
208 if(arguments.Length != 3)
209 {
210 Help(arguments);
211 return ManagedStrongName.ErrorCode;
212 }
213
214 Debug.Assert(arguments[0].EndsWith("e"));
215
216 // parse the arguments
217 string assembly = arguments[1];
218 string output = arguments[2];
219
220 if(String.IsNullOrEmpty(assembly) || String.IsNullOrEmpty(output))
221 {
222 Log.Error(String.Format(
223 CultureInfo.CurrentCulture,
224 Resources.BadFile,
225 String.Empty));
226 return ManagedStrongName.ErrorCode;
227 }
228
229 // do the extraction, and write it out
230 try
231 {
232 byte[] keyBlob = Keys.ExtractPublicKeyFromAssembly(assembly);
233 KeyFile.WriteKeyFile(keyBlob, output);
234 }
235 catch(InvalidOperationException e)
236 {
237 Log.Error(String.Format(
238 CultureInfo.CurrentCulture,
239 Resources.BadOperation,
240 e.Message));
241 return ManagedStrongName.ErrorCode;
242 }
243
244 Log.Message(String.Format(
245 CultureInfo.CurrentCulture,
246 Resources.PublicKeyExtracted,
247 output));
248 return ManagedStrongName.SuccessCode;
249 }
250
251 /// <summary>
252 /// Extract the public key from a key container (-pc)
253 /// </summary>
254 /// <remarks>
255 /// Expects two arguments, the key container and the file to write into
256 /// </remarks>
257 /// <returns>SuccessCode if the key was extracted properly, ErrorCode otherwise</returns>
258 public static int ExtractPublicKeyFromKeyContainer(string[] arguments)
259 {
260 Debug.Assert(arguments != null, "Null arguments");
261
262 if(arguments.Length != 3)
263 {
264 Help(arguments);
265 return ManagedStrongName.ErrorCode;
266 }
267
268 // parse the arguments
269 string keyContainer = arguments[1];
270 string output = arguments[2];
271
272 if(String.IsNullOrEmpty(keyContainer) || String.IsNullOrEmpty(output))
273 {
274 Log.Error(String.Format(
275 CultureInfo.CurrentCulture,
276 Resources.BadFile,
277 String.Empty));
278 return ManagedStrongName.ErrorCode;
279 }
280
281 // do the extraction, and write it out
282 try
283 {
284 byte[] keyBlob = Keys.ExtractPublicKeyFromKeyContainer(keyContainer);
285 KeyFile.WriteKeyFile(keyBlob, output);
286 }
287 catch(InvalidOperationException e)
288 {
289 Log.Error(String.Format(
290 CultureInfo.CurrentCulture,
291 Resources.BadOperation,
292 e.Message));
293 return ManagedStrongName.ErrorCode;
294 }
295
296 Log.Message(String.Format(
297 CultureInfo.CurrentCulture,
298 Resources.PublicKeyExtracted,
299 output));
300 return ManagedStrongName.SuccessCode;
301 }
302
303 /// <summary>
304 /// Extract the public key from a key pair (-p)
305 /// </summary>
306 /// <remarks>
307 /// Expects two arguments, the input file and the file to write into
308 /// </remarks>
309 /// <returns>SuccessCode if the key was extracted properly, ErrorCode otherwise</returns>
310 public static int ExtractPublicKeyFromKeyPair(string[] arguments)
311 {
312 Debug.Assert(arguments != null, "Null arguments");
313
314 if(arguments.Length != 3)
315 {
316 Help(arguments);
317 return ManagedStrongName.ErrorCode;
318 }
319
320 // parse the arguments
321 string keyFile = arguments[1];
322 string output = arguments[2];
323
324 if(String.IsNullOrEmpty(keyFile) || String.IsNullOrEmpty(output))
325 {
326 Log.Error(String.Format(
327 CultureInfo.CurrentCulture,
328 Resources.BadFile,
329 String.Empty));
330 return ManagedStrongName.ErrorCode;
331 }
332
333 // do the extraction, and write it out
334 try
335 {
336 byte[] keyBlob = Keys.ExtractPublicKeyFromKeyPair(KeyFile.ReadKeyFile(keyFile));
337 KeyFile.WriteKeyFile(keyBlob, output);
338 }
339 catch(InvalidOperationException e)
340 {
341 Log.Error(String.Format(
342 CultureInfo.CurrentCulture,
343 Resources.BadOperation,
344 e.Message));
345 return ManagedStrongName.ErrorCode;
346 }
347
348 Log.Message(String.Format(
349 CultureInfo.CurrentCulture,
350 Resources.PublicKeyExtracted,
351 output));
352 return ManagedStrongName.SuccessCode;
353 }
354
355 /// <summary>
356 /// Verify an assembly, ignoring the skip verification registry (-vf)
357 /// </summary>
358 /// <remarks>
359 /// Expects one argument, the name of the assembly to verify
360 /// </remarks>
361 /// <returns>SuccessCode if the signature verifies, ErrorCode otherwise</returns>
362 public static int ForceVerify(string[] arguments)
363 {
364 Debug.Assert(arguments != null, "Null arguments");
365
366 if(arguments.Length != 2)
367 {
368 Help(arguments);
369 return ManagedStrongName.ErrorCode;
370 }
371
372 Debug.Assert(arguments[0].EndsWith("vf"));
373
374 string assembly = arguments[1];
375 if(String.IsNullOrEmpty(assembly))
376 {
377 Log.Error(String.Format(
378 CultureInfo.CurrentCulture,
379 Resources.BadFile,
380 String.Empty));
381 return ManagedStrongName.ErrorCode;
382 }
383
384 switch(Signatures.VerifyAssembly(assembly, true))
385 {
386 case VerificationResult.NotVerified:
387 Log.Message(String.Format(
388 CultureInfo.CurrentCulture,
389 Resources.AssemblyNotVerified,
390 assembly));
391 return ManagedStrongName.ErrorCode;
392
393 case VerificationResult.DelaySigned:
394 Log.Message(String.Format(
395 CultureInfo.CurrentCulture,
396 Resources.AssemblyDelaySigned,
397 assembly));
398 return ManagedStrongName.SuccessCode;
399
400 case VerificationResult.Verified:
401 Log.Message(String.Format(
402 CultureInfo.CurrentCulture,
403 Resources.AssemblyVerified,
404 assembly));
405 return ManagedStrongName.SuccessCode;
406
407 default:
408 Debug.Assert(false, "Unknown verification result");
409 Log.Error(String.Format(
410 CultureInfo.CurrentCulture,
411 Resources.InternalError));
412 return ManagedStrongName.ErrorCode;
413 }
414 }
415
416 /// <summary>
417 /// Generate a key (-k)
418 /// </summary>
419 /// <remarks>
420 /// Expects one or two arguments, key size and file to write to
421 /// </remarks>
422 /// <returns>SuccessCode if the key generated properly, ErrorCode otherwise</returns>
423 public static int GenerateKey(string[] arguments)
424 {
425 Debug.Assert(arguments != null, "Null arguments");
426
427 if(!(arguments.Length == 2 || arguments.Length == 3))
428 {
429 Help(arguments);
430 return ManagedStrongName.ErrorCode;
431 }
432
433 Debug.Assert(arguments[0].EndsWith("k"));
434
435 // parse the arguments
436 int keySize = 1024;
437 string fileName;
438
439 if(arguments.Length == 3)
440 {
441 // specified with both keysize and filename
442 if(!Int32.TryParse(arguments[1], out keySize))
443 {
444 Log.Error(String.Format(
445 CultureInfo.CurrentCulture,
446 Resources.BadKeySize,
447 arguments[1]));
448 return ManagedStrongName.ErrorCode;
449 }
450
451 fileName = arguments[2];
452 }
453 else
454 {
455 // specified with only filename
456 fileName = arguments[1];
457 }
458
459 if(String.IsNullOrEmpty(fileName))
460 {
461 Log.Error(String.Format(
462 CultureInfo.CurrentCulture,
463 Resources.BadFile,
464 String.Empty));
465 return ManagedStrongName.ErrorCode;
466 }
467
468 if(keySize <= 0)
469 Log.Error(String.Format(
470 CultureInfo.CurrentCulture,
471 Resources.BadKeySize,
472 keySize));
473
474 try
475 {
476 byte[] key = Keys.GenerateKeyPair(keySize);
477 KeyFile.WriteKeyFile(key, fileName);
478 }
479 catch(InvalidOperationException e)
480 {
481 Log.Error(String.Format(
482 CultureInfo.CurrentCulture,
483 Resources.BadOperation,
484 e.Message));
485 return ManagedStrongName.ErrorCode;
486 }
487
488 Log.Message(String.Format(
489 CultureInfo.CurrentCulture,
490 Resources.KeyWritten,
491 fileName));
492 return ManagedStrongName.SuccessCode;
493 }
494
495 /// <summary>
496 /// Display usage information
497 /// </summary>
498 public static int Help(string[] arguments)
499 {
500 Log.Message(Resources.Usage);
501 Log.Message(Resources.OptionHeader);
502
503 // sort the commands by option
504 Command[] sortedCommands = new Command[ManagedStrongName.CommandTable.Values.Count];
505 ManagedStrongName.CommandTable.Values.CopyTo(sortedCommands, 0);
506 Array.Sort(sortedCommands);
507
508 // display them all
509 foreach(Command command in sortedCommands)
510 {
511 Log.Message(String.Format(
512 CultureInfo.CurrentCulture,
513 Resources.OptionFormat,
514 command.Option,
515 command.Arguments));
516
517 foreach(string line in ManagedStrongName.FormatHelp(command.Help, 4))
518 Log.Message(line);
519 }
520
521 return ManagedStrongName.SuccessCode;
522 }
523
524 /// <summary>
525 /// Install a key into a key container (-i)
526 /// </summary>
527 /// <remarks>
528 /// Expects two arguments, file name and key container name
529 /// </remarks>
530 /// <returns>SuccessCode if the key generated properly, ErrorCode otherwise</returns>
531 public static int InstallKeyPair(string[] arguments)
532 {
533 Debug.Assert(arguments != null, "Null arguments");
534
535 if(arguments.Length != 3)
536 {
537 Help(arguments);
538 return ManagedStrongName.ErrorCode;
539 }
540
541 Debug.Assert(arguments[0].EndsWith("i"));
542
543 // parse the arguments
544 string keyFile = arguments[1];
545 string keyContainer = arguments[2];
546
547 // do some basic validation on the parameters
548 if(String.IsNullOrEmpty(keyFile) || String.IsNullOrEmpty(keyFile.Trim()))
549 {
550 Log.Error(String.Format(
551 CultureInfo.CurrentCulture,
552 Resources.BadFile,
553 keyFile));
554 return ManagedStrongName.ErrorCode;
555 }
556
557 if(String.IsNullOrEmpty(keyContainer) || String.IsNullOrEmpty(keyContainer.Trim()))
558 {
559 Log.Error(String.Format(
560 CultureInfo.CurrentCulture,
561 Resources.BadKeyContainer,
562 keyContainer));
563 return ManagedStrongName.ErrorCode;
564 }
565
566 try
567 {
568 // install it into the key container
569 Keys.InstallKey(KeyFile.ReadKeyFile(keyFile), keyContainer);
570 }
571 catch(InvalidOperationException e)
572 {
573 Log.Error(String.Format(
574 CultureInfo.CurrentCulture,
575 Resources.BadOperation,
576 e.Message));
577 return ManagedStrongName.ErrorCode;
578 }
579
580 Log.Message(String.Format(
581 CultureInfo.CurrentCulture,
582 Resources.KeyPairInstalled,
583 keyContainer));
584 return ManagedStrongName.SuccessCode;
585 }
586
587 /// <summary>
588 /// Check or set if key store operations should use the machine store (-m)
589 /// </summary>
590 /// <remarks>
591 /// Expects zero or one arguments
592 /// </remarks>
593 /// <returns>SuccessCode if the command finished without error, ErrorCode otherwise</returns>
594 public static int MachineKeyStore(string[] arguments)
595 {
596 Debug.Assert(arguments != null, "Null arguments");
597
598 if(arguments.Length != 1 && arguments.Length != 2)
599 {
600 Help(arguments);
601 return ManagedStrongName.ErrorCode;
602 }
603
604 Debug.Assert(arguments[0].EndsWith("m"));
605
606 if(arguments.Length == 2)
607 {
608 try
609 {
610 // figure out if we're setting to on or off
611 switch(arguments[1].Trim().ToLower(CultureInfo.InvariantCulture))
612 {
613 case "y":
614 Keys.DefaultKeyStore = KeyStore.Machine;
615 break;
616
617 case "n":
618 Keys.DefaultKeyStore = KeyStore.User;
619 break;
620
621 default:
622 Help(arguments);
623 return ManagedStrongName.ErrorCode;
624 }
625 }
626 catch(UnauthorizedAccessException e)
627 {
628 Log.Error(String.Format(
629 CultureInfo.CurrentCulture,
630 Resources.BadOperation,
631 e.Message));
632 return ManagedStrongName.ErrorCode;
633 }
634 catch(InvalidOperationException e)
635 {
636 Log.Error(String.Format(
637 CultureInfo.CurrentCulture,
638 Resources.BadOperation,
639 e.Message));
640 return ManagedStrongName.ErrorCode;
641 }
642 }
643
644 try
645 {
646 // finish by displaying the current state of the machine key store use
647 switch(Keys.DefaultKeyStore)
648 {
649 case KeyStore.Machine:
650 Log.Message(Resources.UsingMachineKeyContainers);
651 break;
652
653 case KeyStore.User:
654 Log.Message(Resources.UsingUserKeyContainers);
655 break;
656
657 default:
658 Log.Message(Resources.InternalError);
659 return ManagedStrongName.ErrorCode;
660 }
661
662 }
663 catch(InvalidOperationException e)
664 {
665 Log.Error(String.Format(
666 CultureInfo.CurrentCulture,
667 Resources.BadOperation,
668 e.Message));
669 return ManagedStrongName.ErrorCode;
670 }
671
672 return ManagedStrongName.SuccessCode;
673 }
674
675 /// <summary>
676 /// Verify an assembly (-v)
677 /// </summary>
678 /// <remarks>
679 /// Expects one argument, the name of the assembly to verify
680 /// </remarks>
681 /// <returns>SuccessCode if the signature verifies, ErrorCode otherwise</returns>
682 public static int Verify(string[] arguments)
683 {
684 Debug.Assert(arguments != null, "Null arguments");
685
686 if(arguments.Length != 2)
687 {
688 Help(arguments);
689 return ManagedStrongName.ErrorCode;
690 }
691
692 Debug.Assert(arguments[0].EndsWith("v"));
693
694 string assembly = arguments[1];
695 if(String.IsNullOrEmpty(assembly))
696 {
697 Log.Error(String.Format(
698 CultureInfo.CurrentCulture,
699 Resources.BadFile,
700 String.Empty));
701 return ManagedStrongName.ErrorCode;
702 }
703
704 switch(Signatures.VerifyAssembly(assembly, false))
705 {
706 case VerificationResult.NotVerified:
707 Log.Message(String.Format(
708 CultureInfo.CurrentCulture,
709 Resources.AssemblyNotVerified,
710 assembly));
711 return ManagedStrongName.ErrorCode;
712
713 case VerificationResult.DelaySigned:
714 Log.Message(String.Format(
715 CultureInfo.CurrentCulture,
716 Resources.AssemblyDelaySigned,
717 assembly));
718 return ManagedStrongName.SuccessCode;
719
720 case VerificationResult.Verified:
721 Log.Message(String.Format(
722 CultureInfo.CurrentCulture,
723 Resources.AssemblyVerified,
724 assembly));
725 return ManagedStrongName.SuccessCode;
726
727 default:
728 Debug.Assert(false, "Unknown verification result");
729 Log.Error(Resources.InternalError);
730 return ManagedStrongName.ErrorCode;
731 }
732 }
733
734 /// <summary>
735 /// Display the public key token, and optionally the key itself, from a file
736 /// </summary>
737 /// <param name="publicKeyFile">
738 /// File the public key is stored into
739 /// </param>
740 /// <param name="displayPublicKey">
741 /// Display the key as well as the token
742 /// </param>
743 /// <returns>SuccessCode on success, ErrorCode on error</returns>
744 private static int DisplayPublicKeyTokenFromFile(string publicKeyFile, bool displayPublicKey)
745 {
746 Debug.Assert(!String.IsNullOrEmpty(publicKeyFile), "No file to work with");
747
748 // get the token and key and write them out
749 try
750 {
751 byte[] key = KeyFile.ReadKeyFile(publicKeyFile);
752 byte[] token = Keys.CreateTokenFromPublicKey(KeyFile.ReadKeyFile(publicKeyFile));
753
754 if(displayPublicKey)
755 {
756 StringBuilder keyString = new StringBuilder(key.Length * 2);
757 foreach(byte b in key)
758 keyString.Append(b.ToString("x2"));
759
760 Log.Message(String.Format(
761 CultureInfo.CurrentCulture,
762 Resources.PublicKey,
763 keyString.ToString()));
764 }
765
766 StringBuilder tokenString = new StringBuilder(token.Length * 2);
767 foreach(byte b in token)
768 tokenString.Append(b.ToString("x2"));
769
770 Log.Message(String.Format(
771 CultureInfo.CurrentCulture,
772 Resources.PublicKeyToken,
773 tokenString.ToString()));
774 }
775 catch(InvalidOperationException e)
776 {
777 Log.Error(String.Format(
778 CultureInfo.CurrentCulture,
779 Resources.BadOperation,
780 e.Message));
781 return ManagedStrongName.ErrorCode;
782 }
783
784 return ManagedStrongName.SuccessCode;
785 }
786
787 /// <summary>
788 /// Display the public key token, and optionally the key itself, from a file
789 /// </summary>
790 /// <param name="assembly">
791 /// File the public key is stored into
792 /// </param>
793 /// <param name="displayPublicKey">
794 /// Display the key as well as the token
795 /// </param>
796 /// <returns>SuccessCode on success, ErrorCode on error</returns>
797 private static int DisplayPublicKeyTokenFromAssembly(string assembly, bool displayPublicKey)
798 {
799 Debug.Assert(!String.IsNullOrEmpty(assembly), "No assembly to work with");
800
801 // write out the public key if requested
802 if(displayPublicKey)
803 {
804 try
805 {
806 byte[] key = Keys.ExtractPublicKeyFromAssembly(assembly);
807 StringBuilder keyString = new StringBuilder(key.Length * 2);
808 foreach(byte b in key)
809 keyString.Append(b.ToString("x2"));
810
811 Log.Message(String.Format(
812 CultureInfo.CurrentCulture,
813 Resources.PublicKey,
814 keyString.ToString()));
815 }
816 catch(InvalidOperationException e)
817 {
818 Log.Error(String.Format(
819 CultureInfo.CurrentCulture,
820 Resources.BadOperation,
821 e.Message));
822 return ManagedStrongName.ErrorCode;
823 }
824 }
825
826 // now write out the token
827 try
828 {
829 byte[] token = Keys.CreateTokenFromAssembly(assembly);
830 StringBuilder tokenString = new StringBuilder(token.Length * 2);
831 foreach(byte b in token)
832 tokenString.Append(b.ToString("x2"));
833
834 Log.Message(String.Format(
835 CultureInfo.CurrentCulture,
836 Resources.PublicKeyToken,
837 tokenString.ToString()));
838
839 }
840 catch(InvalidOperationException e)
841 {
842 Log.Error(String.Format(
843 CultureInfo.CurrentCulture,
844 Resources.BadOperation,
845 e.Message));
846 return ManagedStrongName.ErrorCode;
847 }
848
849 return ManagedStrongName.SuccessCode;
850 }
851 }
852 }
- Anonymous
May 12, 2005
Please call me at 810.629.5369 - Mark Taubits/General Foreman
- Anonymous
April 06, 2007
The comment has been removed