extensions/workben/testpgp.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/types.h>
  21 #ifndef _RTL_WSTRING_
  22 #include <rtl/wstring>
  23 #endif
  24
  25 #include <usr/smartservices.hxx>
  26 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  27 #include <com/sun/star/io/XInputStream.hpp>
  28 #include <com/sun/star/io/XOutputStream.hpp>
  29 #include <com/sun/star/pgp/RecipientsEvent.hpp>
  30 #include <com/sun/star/pgp/SignatureEvent.hpp>
  31 #include <com/sun/star/pgp/XPGPDecoder.hpp>
  32 #include <com/sun/star/pgp/XPGPDecoderListener.hpp>
  33 #include <com/sun/star/pgp/XPGPEncoder.hpp>
  34 #include <com/sun/star/pgp/XPGPPreferences.hpp>
  35 #include <com/sun/star/uno/XInterface.hpp>
  36 #include <com/sun/star/uno/Any.h>
  37 #include <com/sun/star/uno/Reference.h>
  38 #include <com/sun/star/uno/Sequence.hxx>
  39 #include <cppuhelper/weak.hxx>
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44
  45 #include <fcntl.h>
  46 #include <io.h>
  47
  48 using namespace com::sun::star::lang;
  49 using namespace com::sun::star::io;
  50 using namespace com::sun::star::pgp;
  51 using namespace com::sun::star::uno;
  52
  53 /*========================================================================
  54  *
  55  * DataSource_Impl interface.
  56  *
  57  *======================================================================*/
  58 class DataSource_Impl :
  59     public OWeakObject,
  60     public XInputStream
  61 {
  62     Sequence<sal_Int8> m_buffer;
  63     sal_Int32          m_position;
  64     int                m_fd;
  65
  66 public:
  67     DataSource_Impl (int fd = 0);
  68     virtual ~DataSource_Impl();
  69
  70     void setBuffer (const Sequence<sal_Int8> &rBuffer);
  71
  72     /** XInterface.
  73      */
  74     virtual sal_Bool SAL_CALL queryInterface (
  75         const Uik &rUik, Any &rIfc) throw(RuntimeException);
  76
  77     virtual void SAL_CALL acquire() throw(RuntimeException);
  78
  79     virtual void SAL_CALL release() throw(RuntimeException);
  80
  81     /** XInputStream.
  82      */
  83     virtual sal_Int32 SAL_CALL readBytes (
  84         Sequence<sal_Int8> &rData, sal_Int32 nBytesToRead)
  85         throw (NotConnectedException,
  86                BufferSizeExceededException,
  87                IOException);
  88
  89     virtual sal_Int32 SAL_CALL readSomeBytes (
  90         Sequence<sal_Int8> &rData, sal_Int32 nMaxBytesToRead)
  91         throw (NotConnectedException,
  92                BufferSizeExceededException,
  93                IOException);
  94
  95     virtual void SAL_CALL skipBytes (sal_Int32 nBytesToSkip)
  96         throw (NotConnectedException,
  97                BufferSizeExceededException,
  98                IOException);
  99
 100     virtual sal_Int32 SAL_CALL available()
 101         throw (NotConnectedException, IOException);
 102
 103     virtual void SAL_CALL closeInput()
 104         throw (NotConnectedException, IOException);
 105 };
 106
 107 /*========================================================================
 108  *
 109  * DataSink_Impl interface.
 110  *
 111  *======================================================================*/
 112 class DataSink_Impl :
 113     public OWeakObject,
 114     public XOutputStream
 115 {
 116     Sequence<sal_Int8> m_buffer;
 117
 118 public:
 119     DataSink_Impl();
 120     virtual ~DataSink_Impl();
 121
 122     const Sequence<sal_Int8>& getBuffer() const { return m_buffer; }
 123
 124     /** XInterface.
 125      */
 126     virtual sal_Bool SAL_CALL queryInterface (
 127         const Uik &rUik, Any &rIfc) throw(RuntimeException);
 128
 129     virtual void SAL_CALL acquire() throw(RuntimeException);
 130     virtual void SAL_CALL release() throw(RuntimeException);
 131
 132     /** XOutputStream.
 133      */
 134     virtual void SAL_CALL writeBytes (
 135         const Sequence<sal_Int8> &rBuffer)
 136         throw (NotConnectedException,
 137                BufferSizeExceededException,
 138                IOException);
 139
 140     virtual void SAL_CALL flush()
 141         throw (NotConnectedException,
 142                BufferSizeExceededException,
 143                IOException);
 144
 145     virtual void SAL_CALL closeOutput()
 146         throw (NotConnectedException,
 147                BufferSizeExceededException,
 148                IOException);
 149 };
 150
 151 /*========================================================================
 152  *
 153  * DecoderListener_Impl interface.
 154  *
 155  *======================================================================*/
 156 class DecoderListener_Impl :
 157     public OWeakObject,
 158     public XPGPDecoderListener
 159 {
 160 public:
 161     DecoderListener_Impl();
 162     virtual ~DecoderListener_Impl();
 163
 164     /** XInterface.
 165      */
 166     virtual sal_Bool SAL_CALL queryInterface (
 167         const Uik &rUik, Any &rIfc) throw(RuntimeException);
 168
 169     virtual void SAL_CALL acquire() throw(RuntimeException);
 170
 171     virtual void SAL_CALL release() throw(RuntimeException);
 172
 173     /** XEventListener.
 174      */
 175     virtual void SAL_CALL disposing (const EventObject &rSource);
 176
 177     /** XPGPDecoderListener.
 178      */
 179     virtual void SAL_CALL decrypted (const RecipientsEvent &rEvent);
 180     virtual void SAL_CALL verified  (const SignatureEvent &rEvent);
 181 };
 182
 183 /*========================================================================
 184  *
 185  * DataSource_Impl implementation.
 186  *
 187  *======================================================================*/
 188 /*
 189  * DataSource_Impl.
 190  */
 191 DataSource_Impl::DataSource_Impl (int fd)
 192     : m_fd (fd), m_position (0)
 193 {
 194 }
 195
 196 /*
 197  * ~DataSource_Impl.
 198  */
 199 DataSource_Impl::~DataSource_Impl()
 200 {
 201 }
 202
 203 /*
 204  * DataSource_Impl: setBuffer.
 205  */
 206 void DataSource_Impl::setBuffer (const Sequence<sal_Int8> &rBuffer)
 207 {
 208     m_buffer = rBuffer;
 209     if (!m_buffer.getLength())
 210     {
 211         // Fill buffer from file descriptor.
 212         char buffer[1024];
 213         memset (buffer, 0, sizeof(buffer));
 214
 215         int k = read (m_fd, buffer, sizeof(buffer));
 216         while (k > 0)
 217         {
 218             sal_Int32 n = m_buffer.getLength();
 219             m_buffer.realloc (n + k);
 220
 221             memcpy (m_buffer.getArray() + n, buffer, k);
 222             n += k;
 223
 224             memset (buffer, 0, k);
 225             k = read (m_fd, buffer, sizeof(buffer));
 226         }
 227     }
 228     m_position = 0;
 229 }
 230
 231 /*
 232  * XInterface: queryInterface.
 233  */
 234 sal_Bool SAL_CALL DataSource_Impl::queryInterface (
 235     const Uik &rUik, Any &rIfc) throw(RuntimeException)
 236 {
 237     if (com::sun::star::uno::queryInterface (
 238         rUik, rIfc,
 239         (static_cast< XInputStream* >(this))))
 240         return sal_True;
 241     else
 242         return OWeakObject::queryInterface (rUik, rIfc);
 243 }
 244
 245 /*
 246  * XInterface: acquire.
 247  */
 248 void SAL_CALL DataSource_Impl::acquire() throw(RuntimeException)
 249 {
 250     OWeakObject::acquire();
 251 }
 252
 253 /*
 254  * XInterface: release.
 255  */
 256 void SAL_CALL DataSource_Impl::release() throw(RuntimeException)
 257 {
 258     OWeakObject::release();
 259 }
 260
 261 /*
 262  * XInputStream: readBytes.
 263  */
 264 sal_Int32 SAL_CALL DataSource_Impl::readBytes (
 265     Sequence<sal_Int8> &rData, sal_Int32 nBytesToRead)
 266     throw (NotConnectedException, BufferSizeExceededException, IOException)
 267 {
 268     if (nBytesToRead < 0)
 269         throw IOException();
 270
 271     sal_Int32 k = m_buffer.getLength() - m_position;
 272     k = SAL_BOUND(k, 0, nBytesToRead);
 273     if (k > 0)
 274     {
 275         rData.realloc(k);
 276         memcpy (
 277             rData.getArray(), m_buffer.getConstArray() + m_position, k);
 278         m_position += k;
 279     }
 280     return k;
 281 }
 282
 283 /*
 284  * XInputStream: readSomeBytes.
 285  */
 286 sal_Int32 SAL_CALL DataSource_Impl::readSomeBytes (
 287     Sequence<sal_Int8> &rData, sal_Int32 nMaxBytesToRead)
 288     throw (NotConnectedException, BufferSizeExceededException, IOException)
 289 {
 290     return readBytes (rData, nMaxBytesToRead);
 291 }
 292
 293 /*
 294  * XInputStream: skipBytes.
 295  */
 296 void SAL_CALL DataSource_Impl::skipBytes (sal_Int32 nBytesToSkip)
 297     throw (NotConnectedException, BufferSizeExceededException, IOException)
 298 {
 299     if (nBytesToSkip < 0)
 300         throw IOException();
 301
 302     m_position += nBytesToSkip;
 303 }
 304
 305 /*
 306  * XInputStream: available.
 307  */
 308 sal_Int32 SAL_CALL DataSource_Impl::available()
 309     throw (NotConnectedException, IOException)
 310 {
 311     sal_Int32 k = m_buffer.getLength() - m_position;
 312     return ((k > 0) ? k : 0);
 313 }
 314
 315 /*
 316  * XInputStream: closeInput.
 317  */
 318 void SAL_CALL DataSource_Impl::closeInput()
 319     throw (NotConnectedException, IOException)
 320 {
 321 }
 322
 323 /*========================================================================
 324  *
 325  * DataSink_Impl implementation.
 326  *
 327  *======================================================================*/
 328 /*
 329  * DataSink_Impl.
 330  */
 331 DataSink_Impl::DataSink_Impl()
 332 {
 333 }
 334
 335 /*
 336  * ~DataSink_Impl.
 337  */
 338 DataSink_Impl::~DataSink_Impl()
 339 {
 340 }
 341
 342 /*
 343  * XInterface: queryInterface.
 344  */
 345 sal_Bool SAL_CALL DataSink_Impl::queryInterface (
 346     const Uik &rUik, Any &rIfc) throw(RuntimeException)
 347 {
 348     if (com::sun::star::uno::queryInterface (
 349         rUik, rIfc,
 350         (static_cast< XOutputStream* >(this))))
 351         return sal_True;
 352     else
 353         return OWeakObject::queryInterface (rUik, rIfc);
 354 }
 355
 356 /*
 357  * XInterface: acquire.
 358  */
 359 void SAL_CALL DataSink_Impl::acquire() throw(RuntimeException)
 360 {
 361     OWeakObject::acquire();
 362 }
 363
 364 /*
 365  * XInterface: release.
 366  */
 367 void SAL_CALL DataSink_Impl::release() throw(RuntimeException)
 368 {
 369     OWeakObject::release();
 370 }
 371
 372 /*
 373  * XOutputStream: writeBytes.
 374  */
 375 void SAL_CALL DataSink_Impl::writeBytes (const Sequence<sal_Int8> &rBuffer)
 376     throw (NotConnectedException, BufferSizeExceededException, IOException)
 377 {
 378     if (rBuffer.getLength())
 379     {
 380         sal_Int32 n = m_buffer.getLength();
 381         m_buffer.realloc (n + rBuffer.getLength());
 382
 383         memcpy (
 384             m_buffer.getArray() + n,
 385             rBuffer.getConstArray(),
 386             rBuffer.getLength());
 387     }
 388 }
 389
 390 /*
 391  * XOutputStream: flush.
 392  */
 393 void SAL_CALL DataSink_Impl::flush()
 394     throw (NotConnectedException, BufferSizeExceededException, IOException)
 395 {
 396     if (m_buffer.getLength())
 397     {
 398         // Write data to stdout.
 399         const sal_Int8 *pData = m_buffer.getConstArray();
 400         sal_Int32       nData = m_buffer.getLength();
 401
 402         int prev = ::setmode (1, O_BINARY);
 403         if (!(prev < 0))
 404         {
 405             int k = ::write (1, pData, nData);
 406             if (k > 0)
 407                 ::write (1, "\n", 1);
 408             ::setmode (1, prev);
 409         }
 410     }
 411 }
 412
 413 /*
 414  * XOutputStream: closeOutput.
 415  */
 416 void SAL_CALL DataSink_Impl::closeOutput()
 417     throw (NotConnectedException, BufferSizeExceededException, IOException)
 418 {
 419     flush();
 420 }
 421
 422 /*========================================================================
 423  *
 424  * DecoderListener_Impl implementation.
 425  *
 426  *======================================================================*/
 427 /*
 428  * DecoderListener_Impl.
 429  */
 430 DecoderListener_Impl::DecoderListener_Impl()
 431 {
 432 }
 433
 434 /*
 435  * ~DecoderListener_Impl.
 436  */
 437 DecoderListener_Impl::~DecoderListener_Impl()
 438 {
 439 }
 440
 441 /*
 442  * XInterface: queryInterface.
 443  */
 444 sal_Bool SAL_CALL DecoderListener_Impl::queryInterface (
 445     const Uik &rUik, Any &rIfc) throw(RuntimeException)
 446 {
 447     if (com::sun::star::uno::queryInterface (
 448         rUik, rIfc,
 449         (static_cast< XEventListener* >(this)),
 450         (static_cast< XPGPDecoderListener* >(this))))
 451         return sal_True;
 452     else
 453         return OWeakObject::queryInterface (rUik, rIfc);
 454 }
 455
 456 /*
 457  * XInterface: acquire.
 458  */
 459 void SAL_CALL DecoderListener_Impl::acquire() throw(RuntimeException)
 460 {
 461     OWeakObject::acquire();
 462 }
 463
 464 /*
 465  * XInterface: release.
 466  */
 467 void SAL_CALL DecoderListener_Impl::release() throw(RuntimeException)
 468 {
 469     OWeakObject::release();
 470 }
 471
 472 /*
 473  * XEventListener: disposing.
 474  */
 475 void SAL_CALL DecoderListener_Impl::disposing (const EventObject &rSource)
 476 {
 477 }
 478
 479 /*
 480  * XPGPDecoderListener: decrypted.
 481  */
 482 void SAL_CALL DecoderListener_Impl::decrypted (const RecipientsEvent &rEvent)
 483 {
 484 }
 485
 486 /*
 487  * XPGPDecoderListener: verified.
 488  */
 489 void SAL_CALL DecoderListener_Impl::verified (const SignatureEvent &rEvent)
 490 {
 491 }
 492
 493 /*========================================================================
 494  *
 495  * Main.
 496  *
 497  *======================================================================*/
 498 inline rtl::OWString S2U (const sal_Char *ascii)
 499 {
 500     return rtl::OWString::createFromAscii (ascii);
 501 }
 502
 503 /*
 504  * main.
 505  */
 506 int SAL_CALL main (int argc, char **argv)
 507 {
 508     enum Option
 509     {
 510         OPTION_INSTALL   = 0x01,
 511         OPTION_UNINSTALL = 0x02,
 512
 513         OPTION_DECRYPT   = 0x04,
 514         OPTION_ENCRYPT   = 0x08,
 515         OPTION_SIGN      = 0x10,
 516
 517         OPTION_FILE      = 0x20,
 518         OPTION_HELP      = 0x40
 519     };
 520
 521     int fd = 0;
 522     unsigned long nOptions = 0;
 523
 524     for (int i = 1; i < argc; i++)
 525     {
 526         const char *opt = argv[i];
 527         if (opt[0] == '-')
 528         {
 529             switch (opt[1])
 530             {
 531                 case 'i':
 532                     nOptions |= OPTION_INSTALL;
 533                     break;
 534
 535                 case 'u':
 536                     nOptions |= OPTION_UNINSTALL;
 537                     break;
 538
 539                 case 'd':
 540                     nOptions |= OPTION_DECRYPT;
 541                     break;
 542
 543                 case 'e':
 544                     nOptions |= OPTION_ENCRYPT;
 545                     break;
 546
 547                 case 's':
 548                     nOptions |= OPTION_SIGN;
 549                     break;
 550
 551                 case 'f':
 552                     nOptions |= OPTION_FILE;
 553                     break;
 554
 555                 case 'h':
 556                 default:
 557                     nOptions |= OPTION_HELP;
 558                     break;
 559             }
 560         }
 561         else
 562         {
 563             if (nOptions & OPTION_FILE)
 564             {
 565                 if ((fd = open (argv[i], O_RDONLY | O_BINARY)) < 0)
 566                 {
 567                     printf ("Error: can't open file: %s\n", argv[i]);
 568                     exit (0);
 569                 }
 570             }
 571         }
 572     }
 573
 574     if ((nOptions == 0) || (nOptions & OPTION_HELP))
 575     {
 576         printf ("Options:\n");
 577         printf ("-i\tinstall module\n");
 578         printf ("-u\tuninstall module\n");
 579         printf ("-d\tdecrypt and verify\n");
 580         printf ("-e\tencrypt test pattern\n");
 581         printf ("-s\tsign test pattern\n");
 582         printf ("-h\thelp\n");
 583         exit (0);
 584     }
 585
 586     Reference<XMultiServiceFactory> xManager (
 587         usr::createDefaultSmartRegistryServiceFactory());
 588     if (!xManager.is())
 589     {
 590         printf ("Error: no ProcessServiceManager.\n");
 591         exit (1);
 592     }
 593     usr::setProcessServiceFactory (xManager);
 594
 595     if (nOptions & OPTION_INSTALL)
 596     {
 597
 598     }
 599
 600     if (nOptions & (OPTION_DECRYPT | OPTION_ENCRYPT | OPTION_SIGN))
 601     {
 602         Reference<XMultiServiceFactory> xProv (
 603             xManager->createInstance (
 604                 S2U("com.sun.star.pgp.PGPFactory")),
 605             UNO_QUERY);
 606         if (!xProv.is())
 607         {
 608             printf ("Error: no PGPFactory service.\n");
 609             exit (1);
 610         }
 611
 612         Reference<XInterface> xProvInst (
 613             xProv->createInstance (
 614                 S2U("com.sun.star.pgp.SimplePGPMailer")));
 615         if (!xProvInst.is())
 616         {
 617             printf ("Error: no SimplePGPMailer service.\n");
 618             exit (2);
 619         }
 620
 621         Reference<XPGPPreferences> xPrefs (xProvInst, UNO_QUERY);
 622         if (xPrefs.is())
 623         {
 624             unsigned long nDefaults = 0;
 625
 626             if (xPrefs->getEncryptByDefault())
 627                 nDefaults |= OPTION_ENCRYPT;
 628             if (xPrefs->getSignByDefault())
 629                 nDefaults |= OPTION_SIGN;
 630             if (xPrefs->getAutoDecrypt())
 631                 nDefaults |= OPTION_DECRYPT;
 632
 633             if (nDefaults)
 634             {
 635             }
 636         }
 637
 638         static const sal_Int8 pData[] = "" /* "Hello PGP World." */;
 639         Sequence<sal_Int8> buffer (pData, sizeof (pData) - 1);
 640
 641         if (nOptions & (OPTION_ENCRYPT | OPTION_SIGN))
 642         {
 643             Reference<XPGPEncoder> xEncoder (xProvInst, UNO_QUERY);
 644             if (!xEncoder.is())
 645             {
 646                 printf ("Error: no PGPEncoder interface.\n");
 647                 exit (4);
 648             }
 649
 650             DataSource_Impl *source = new DataSource_Impl (fd);
 651             source->setBuffer (buffer);
 652
 653             DataSink_Impl *sink = new DataSink_Impl;
 654
 655             Reference<XInputStream>  xPlainText  (source);
 656             Reference<XOutputStream> xCipherText (sink);
 657
 658             if (nOptions & OPTION_ENCRYPT)
 659             {
 660                 rtl::OWString aRecipients[] =
 661                 {
 662                     S2U("er@stardiv.de"),
 663                     // L"mhu@stardivision.de",
 664                     S2U("mhu@rabbit")
 665                 };
 666
 667                 sal_Int32 nRecipients = SAL_N_ELEMENTS(aRecipients);
 668
 669                 if (nOptions & OPTION_SIGN)
 670                 {
 671                     xEncoder->encryptAndSign (
 672                         Sequence<rtl::OWString>(aRecipients, nRecipients),
 673                         xPlainText,
 674                         xCipherText);
 675                     nOptions &= ~OPTION_SIGN;
 676                 }
 677                 else
 678                 {
 679                     xEncoder->encrypt (
 680                         Sequence<rtl::OWString>(aRecipients, nRecipients),
 681                         xPlainText,
 682                         xCipherText);
 683                 }
 684                 nOptions &= ~OPTION_ENCRYPT;
 685             }
 686
 687             if (nOptions & OPTION_SIGN)
 688             {
 689                 sal_Bool bDataIsAscii = (fd == 0); // stdin.
 690
 691                 xEncoder->sign (
 692                     bDataIsAscii,
 693                     xPlainText,
 694                     xCipherText);
 695                 nOptions &= ~OPTION_SIGN;
 696             }
 697
 698             buffer = sink->getBuffer();
 699         }
 700
 701         if (nOptions & OPTION_DECRYPT)
 702         {
 703             Reference<XPGPDecoder> xDecoder (xProvInst, UNO_QUERY);
 704             if (!xDecoder.is())
 705             {
 706                 printf ("Error: no PGPDecoder interface.\n");
 707                 exit (5);
 708             }
 709
 710             DataSource_Impl *source = new DataSource_Impl;
 711             source->setBuffer (buffer);
 712
 713             DataSink_Impl *sink = new DataSink_Impl;
 714
 715             Reference<XInputStream>  xCipherText (source);
 716             Reference<XOutputStream> xPlainText  (sink);
 717
 718             Reference<XPGPDecoderListener> xListener (
 719                 new DecoderListener_Impl);
 720             xDecoder->addDecoderListener (xListener);
 721
 722             xDecoder->decryptAndVerify (
 723                 xCipherText,
 724                 xPlainText);
 725             nOptions &= ~OPTION_DECRYPT;
 726
 727             xDecoder->removeDecoderListener (xListener);
 728
 729             buffer = sink->getBuffer();
 730         }
 731     }
 732
 733     if (nOptions & OPTION_UNINSTALL)
 734     {
 735
 736     }
 737
 738     return 0;
 739 }
 740
 741 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */