File indexing completed on 2024-02-25 04:52:37

0001 /*
0002  * Copyright (C) 2003-2007  Justin Karneges <justin@affinix.com>
0003  * Copyright (C) 2004,2005  Brad Hards <bradh@frogmouth.net>
0004  *
0005  * This library is free software; you can redistribute it and/or
0006  * modify it under the terms of the GNU Lesser General Public
0007  * License as published by the Free Software Foundation; either
0008  * version 2.1 of the License, or (at your option) any later version.
0009  *
0010  * This library is distributed in the hope that it will be useful,
0011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
0012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
0013  * Lesser General Public License for more details.
0014  *
0015  * You should have received a copy of the GNU Lesser General Public
0016  * License along with this library; if not, write to the Free Software
0017  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
0018  * 02110-1301  USA
0019  *
0020  */
0021 
0022 #include "qca_tools.h"
0023 
0024 #include "qdebug.h"
0025 
0026 #ifdef Q_OS_UNIX
0027 #include <cstdlib>
0028 #include <sys/mman.h>
0029 #endif
0030 #include "botantools/botantools.h"
0031 
0032 namespace QCA {
0033 
0034 static bool can_lock()
0035 {
0036 #ifdef Q_OS_UNIX
0037     bool ok = false;
0038 #ifdef MLOCK_NOT_VOID_PTR
0039 #define MLOCK_TYPE char *
0040 #define MLOCK_TYPE_CAST (MLOCK_TYPE)
0041 #else
0042 #define MLOCK_TYPE void *
0043 #define MLOCK_TYPE_CAST
0044 #endif
0045 
0046     MLOCK_TYPE d = MLOCK_TYPE_CAST malloc(256);
0047     if (mlock(d, 256) == 0) {
0048         munlock(d, 256);
0049         ok = true;
0050     }
0051     free(d);
0052     return ok;
0053 #else
0054     return true;
0055 #endif
0056 }
0057 
0058 // Botan shouldn't throw any exceptions in our init/deinit.
0059 
0060 static Botan::Allocator *alloc = nullptr;
0061 
0062 void botan_throw_abort()
0063 {
0064     fprintf(stderr, "QCA: Exception from internal Botan\n");
0065     abort();
0066 }
0067 
0068 bool botan_init(int prealloc, bool mmap)
0069 {
0070     // 64k minimum
0071     if (prealloc < 64)
0072         prealloc = 64;
0073 
0074     bool secmem = false;
0075 
0076     try {
0077         Botan::Builtin_Modules modules;
0078         Botan::Library_State  *libstate = new Botan::Library_State(modules.mutex_factory());
0079         libstate->prealloc_size         = prealloc * 1024;
0080         Botan::set_global_state(libstate);
0081         Botan::global_state().load(modules);
0082 
0083         if (can_lock()) {
0084             Botan::global_state().set_default_allocator("locking");
0085             secmem = true;
0086         } else if (mmap) {
0087             Botan::global_state().set_default_allocator("mmap");
0088             secmem = true;
0089         }
0090         alloc = Botan::Allocator::get(true);
0091     } catch (std::exception &) {
0092         fprintf(stderr, "QCA: Error initializing internal Botan\n");
0093         abort();
0094     }
0095 
0096     return secmem;
0097 }
0098 
0099 void botan_deinit()
0100 {
0101     try {
0102         alloc = nullptr;
0103         Botan::set_global_state(nullptr);
0104     } catch (std::exception &) {
0105         botan_throw_abort();
0106     }
0107 }
0108 
0109 void *botan_secure_alloc(int bytes)
0110 {
0111     try {
0112         return alloc->allocate((Botan::u32bit)bytes);
0113     } catch (std::exception &) {
0114         botan_throw_abort();
0115     }
0116     return nullptr; // never get here
0117 }
0118 
0119 void botan_secure_free(void *p, int bytes)
0120 {
0121     try {
0122         alloc->deallocate(p, (Botan::u32bit)bytes);
0123     } catch (std::exception &) {
0124         botan_throw_abort();
0125     }
0126 }
0127 
0128 } // end namespace QCA
0129 
0130 void *qca_secure_alloc(int bytes)
0131 {
0132     // allocate enough room to store a size value in front, return a pointer after it
0133     char *c                       = (char *)QCA::botan_secure_alloc(bytes + sizeof(int));
0134     reinterpret_cast<int *>(c)[0] = bytes + sizeof(int);
0135     return c + sizeof(int);
0136 }
0137 
0138 void qca_secure_free(void *p)
0139 {
0140     // backtrack to read the size value
0141     char *c = (char *)p;
0142     c -= sizeof(int);
0143     const int bytes = reinterpret_cast<int *>(c)[0];
0144     QCA::botan_secure_free(c, bytes);
0145 }
0146 
0147 void *qca_secure_realloc(void *p, int bytes)
0148 {
0149     // if null, do a plain alloc (just like how realloc() works)
0150     if (!p)
0151         return qca_secure_alloc(bytes);
0152 
0153     // backtrack to read the size value
0154     char *c = (char *)p;
0155     c -= sizeof(int);
0156     const int oldsize = reinterpret_cast<int *>(c)[0] - sizeof(int);
0157 
0158     // alloc the new chunk
0159     char *new_p = (char *)qca_secure_alloc(bytes);
0160     if (!new_p)
0161         return nullptr;
0162 
0163     // move over the memory from the original block
0164     memmove(new_p, p, qMin(oldsize, bytes));
0165 
0166     // free the original
0167     qca_secure_free(p);
0168 
0169     // done
0170     return new_p;
0171 }
0172 
0173 namespace QCA {
0174 
0175 // secure or non-secure buffer, with trailing 0-byte.
0176 // buffer size of 0 is okay (sbuf/qbuf will be 0).
0177 struct alloc_info
0178 {
0179     bool  sec;
0180     char *data;
0181     int   size;
0182 
0183     // internal
0184     Botan::SecureVector<Botan::byte> *sbuf;
0185     QByteArray                       *qbuf;
0186 };
0187 
0188 // note: these functions don't return error if memory allocation/resizing
0189 //   fails..  maybe fix this someday?
0190 
0191 // ai: uninitialized
0192 // size: >= 0
0193 // note: memory will be initially zero'd out
0194 static bool ai_new(alloc_info *ai, int size, bool sec);
0195 
0196 // ai: uninitialized
0197 // from: initialized
0198 static bool ai_copy(alloc_info *ai, const alloc_info *from);
0199 
0200 // ai: initialized
0201 // new_size: >= 0
0202 static bool ai_resize(alloc_info *ai, int new_size);
0203 
0204 // ai: initialized
0205 static void ai_delete(alloc_info *ai);
0206 
0207 bool ai_new(alloc_info *ai, int size, bool sec)
0208 {
0209     if (size < 0)
0210         return false;
0211 
0212     ai->size = size;
0213     ai->sec  = sec;
0214 
0215     if (size == 0) {
0216         ai->sbuf = nullptr;
0217         ai->qbuf = nullptr;
0218         ai->data = nullptr;
0219         return true;
0220     }
0221 
0222     if (sec) {
0223         try {
0224             ai->sbuf = new Botan::SecureVector<Botan::byte>((Botan::u32bit)size + 1);
0225         } catch (std::exception &) {
0226             botan_throw_abort();
0227             return false; // never get here
0228         }
0229 
0230         (*(ai->sbuf))[size] = 0;
0231         ai->qbuf            = nullptr;
0232         Botan::byte *bp     = (Botan::byte *)(*(ai->sbuf));
0233         ai->data            = (char *)bp;
0234     } else {
0235         ai->sbuf = nullptr;
0236         ai->qbuf = new QByteArray(size, 0);
0237         ai->data = ai->qbuf->data();
0238     }
0239 
0240     return true;
0241 }
0242 
0243 bool ai_copy(alloc_info *ai, const alloc_info *from)
0244 {
0245     ai->size = from->size;
0246     ai->sec  = from->sec;
0247 
0248     if (ai->size == 0) {
0249         ai->sbuf = nullptr;
0250         ai->qbuf = nullptr;
0251         ai->data = nullptr;
0252         return true;
0253     }
0254 
0255     if (ai->sec) {
0256         try {
0257             ai->sbuf = new Botan::SecureVector<Botan::byte>(*(from->sbuf));
0258         } catch (std::exception &) {
0259             botan_throw_abort();
0260             return false; // never get here
0261         }
0262 
0263         ai->qbuf        = nullptr;
0264         Botan::byte *bp = (Botan::byte *)(*(ai->sbuf));
0265         ai->data        = (char *)bp;
0266     } else {
0267         ai->sbuf = nullptr;
0268         ai->qbuf = new QByteArray(*(from->qbuf));
0269         ai->data = ai->qbuf->data();
0270     }
0271 
0272     return true;
0273 }
0274 
0275 bool ai_resize(alloc_info *ai, int new_size)
0276 {
0277     if (new_size < 0)
0278         return false;
0279 
0280     // new size is empty
0281     if (new_size == 0) {
0282         // we currently aren't empty
0283         if (ai->size > 0) {
0284             if (ai->sec) {
0285                 delete ai->sbuf;
0286                 ai->sbuf = nullptr;
0287             } else {
0288                 delete ai->qbuf;
0289                 ai->qbuf = nullptr;
0290             }
0291 
0292             ai->size = 0;
0293             ai->data = nullptr;
0294         }
0295 
0296         return true;
0297     }
0298 
0299     if (ai->sec) {
0300         Botan::SecureVector<Botan::byte> *new_buf;
0301         try {
0302             new_buf = new Botan::SecureVector<Botan::byte>((Botan::u32bit)new_size + 1);
0303         } catch (std::exception &) {
0304             botan_throw_abort();
0305             return false; // never get here
0306         }
0307 
0308         Botan::byte *new_p = (Botan::byte *)(*new_buf);
0309         if (ai->size > 0) {
0310             const Botan::byte *old_p = (const Botan::byte *)(*(ai->sbuf));
0311             memcpy(new_p, old_p, qMin(new_size, ai->size));
0312             delete ai->sbuf;
0313         }
0314         ai->sbuf                = new_buf;
0315         ai->size                = new_size;
0316         (*(ai->sbuf))[new_size] = 0;
0317         ai->data                = (char *)new_p;
0318     } else {
0319         if (ai->size > 0)
0320             ai->qbuf->resize(new_size);
0321         else
0322             ai->qbuf = new QByteArray(new_size, 0);
0323 
0324         ai->size = new_size;
0325         ai->data = ai->qbuf->data();
0326     }
0327 
0328     return true;
0329 }
0330 
0331 void ai_delete(alloc_info *ai)
0332 {
0333     if (ai->size > 0) {
0334         if (ai->sec)
0335             delete ai->sbuf;
0336         else
0337             delete ai->qbuf;
0338     }
0339 }
0340 
0341 //----------------------------------------------------------------------------
0342 // MemoryRegion
0343 //----------------------------------------------------------------------------
0344 static char blank[] = "";
0345 
0346 class MemoryRegion::Private : public QSharedData
0347 {
0348 public:
0349     alloc_info ai;
0350 
0351     Private(int size, bool sec)
0352     {
0353         ai_new(&ai, size, sec);
0354     }
0355 
0356     Private(const QByteArray &from, bool sec)
0357     {
0358         ai_new(&ai, from.size(), sec);
0359         memcpy(ai.data, from.data(), ai.size);
0360     }
0361 
0362     Private(const Private &from)
0363         : QSharedData(from)
0364     {
0365         ai_copy(&ai, &from.ai);
0366     }
0367 
0368     ~Private()
0369     {
0370         ai_delete(&ai);
0371     }
0372 
0373     bool resize(int new_size)
0374     {
0375         return ai_resize(&ai, new_size);
0376     }
0377 
0378     void setSecure(bool sec)
0379     {
0380         // if same mode, do nothing
0381         if (ai.sec == sec)
0382             return;
0383 
0384         alloc_info other;
0385         ai_new(&other, ai.size, sec);
0386         memcpy(other.data, ai.data, ai.size);
0387         ai_delete(&ai);
0388         ai = other;
0389     }
0390 };
0391 
0392 MemoryRegion::MemoryRegion()
0393     : _secure(false)
0394     , d(nullptr)
0395 {
0396 }
0397 
0398 MemoryRegion::MemoryRegion(const char *str)
0399     : _secure(false)
0400     , d(new Private(QByteArray::fromRawData(str, strlen(str)), false))
0401 {
0402 }
0403 
0404 MemoryRegion::MemoryRegion(const QByteArray &from)
0405     : _secure(false)
0406     , d(new Private(from, false))
0407 {
0408 }
0409 
0410 MemoryRegion::MemoryRegion(const MemoryRegion &from)
0411     : _secure(from._secure)
0412     , d(from.d)
0413 {
0414 }
0415 
0416 MemoryRegion::~MemoryRegion()
0417 {
0418 }
0419 
0420 MemoryRegion &MemoryRegion::operator=(const MemoryRegion &from)
0421 {
0422     _secure = from._secure;
0423     d       = from.d;
0424     return *this;
0425 }
0426 
0427 MemoryRegion &MemoryRegion::operator=(const QByteArray &from)
0428 {
0429     set(from, false);
0430     return *this;
0431 }
0432 
0433 bool MemoryRegion::isNull() const
0434 {
0435     return (d ? false : true);
0436 }
0437 
0438 bool MemoryRegion::isSecure() const
0439 {
0440     return _secure;
0441 }
0442 
0443 QByteArray MemoryRegion::toByteArray() const
0444 {
0445     if (!d)
0446         return QByteArray();
0447 
0448     if (d->ai.sec) {
0449         QByteArray buf(d->ai.size, 0);
0450         memcpy(buf.data(), d->ai.data, d->ai.size);
0451         return buf;
0452     } else {
0453         if (d->ai.size > 0)
0454             return *(d->ai.qbuf);
0455         else
0456             return QByteArray((int)0, (char)0);
0457     }
0458 }
0459 
0460 MemoryRegion::MemoryRegion(bool secure)
0461     : _secure(secure)
0462     , d(nullptr)
0463 {
0464 }
0465 
0466 MemoryRegion::MemoryRegion(int size, bool secure)
0467     : _secure(secure)
0468     , d(new Private(size, secure))
0469 {
0470 }
0471 
0472 MemoryRegion::MemoryRegion(const QByteArray &from, bool secure)
0473     : _secure(secure)
0474     , d(new Private(from, secure))
0475 {
0476 }
0477 
0478 char *MemoryRegion::data()
0479 {
0480     if (!d)
0481         return blank;
0482     return d->ai.data;
0483 }
0484 
0485 const char *MemoryRegion::data() const
0486 {
0487     if (!d)
0488         return blank;
0489     return d->ai.data;
0490 }
0491 
0492 const char *MemoryRegion::constData() const
0493 {
0494     if (!d)
0495         return blank;
0496     return d->ai.data;
0497 }
0498 
0499 char &MemoryRegion::at(int index)
0500 {
0501     return *(d->ai.data + index);
0502 }
0503 
0504 const char &MemoryRegion::at(int index) const
0505 {
0506     return *(d->ai.data + index);
0507 }
0508 
0509 int MemoryRegion::size() const
0510 {
0511     if (!d)
0512         return 0;
0513     return d->ai.size;
0514 }
0515 
0516 bool MemoryRegion::isEmpty() const
0517 {
0518     if (!d)
0519         return true;
0520     return (d->ai.size > 0 ? false : true);
0521 }
0522 
0523 bool MemoryRegion::resize(int size)
0524 {
0525     if (!d) {
0526         d = new Private(size, _secure);
0527         return true;
0528     }
0529 
0530     if (d->ai.size == size)
0531         return true;
0532 
0533     return d->resize(size);
0534 }
0535 
0536 void MemoryRegion::set(const QByteArray &from, bool secure)
0537 {
0538     _secure = secure;
0539 
0540     if (!from.isEmpty())
0541         d = new Private(from, secure);
0542     else
0543         d = new Private(0, secure);
0544 }
0545 
0546 void MemoryRegion::setSecure(bool secure)
0547 {
0548     _secure = secure;
0549 
0550     if (!d) {
0551         d = new Private(0, secure);
0552         return;
0553     }
0554 
0555     d->setSecure(secure);
0556 }
0557 
0558 //----------------------------------------------------------------------------
0559 // SecureArray
0560 //----------------------------------------------------------------------------
0561 SecureArray::SecureArray()
0562     : MemoryRegion(true)
0563 {
0564 }
0565 
0566 SecureArray::SecureArray(int size, char ch)
0567     : MemoryRegion(size, true)
0568 {
0569     // ai_new fills with zeros for us
0570     if (ch != 0)
0571         fill(ch, size);
0572 }
0573 
0574 SecureArray::SecureArray(const char *str)
0575     : MemoryRegion(QByteArray::fromRawData(str, strlen(str)), true)
0576 {
0577 }
0578 
0579 SecureArray::SecureArray(const QByteArray &a)
0580     : MemoryRegion(a, true)
0581 {
0582 }
0583 
0584 SecureArray::SecureArray(const MemoryRegion &a)
0585     : MemoryRegion(a)
0586 {
0587     setSecure(true);
0588 }
0589 
0590 SecureArray::SecureArray(const SecureArray &from)
0591     : MemoryRegion(from)
0592 {
0593 }
0594 
0595 SecureArray::~SecureArray()
0596 {
0597 }
0598 
0599 SecureArray &SecureArray::operator=(const SecureArray &from)
0600 {
0601     MemoryRegion::operator=(from);
0602     return *this;
0603 }
0604 
0605 SecureArray &SecureArray::operator=(const QByteArray &from)
0606 {
0607     MemoryRegion::set(from, true);
0608     return *this;
0609 }
0610 
0611 void SecureArray::clear()
0612 {
0613     MemoryRegion::resize(0);
0614 }
0615 
0616 bool SecureArray::resize(int size)
0617 {
0618     return MemoryRegion::resize(size);
0619 }
0620 
0621 char &SecureArray::operator[](int index)
0622 {
0623     return at(index);
0624 }
0625 
0626 const char &SecureArray::operator[](int index) const
0627 {
0628     return at(index);
0629 }
0630 
0631 char &SecureArray::at(int index)
0632 {
0633     return MemoryRegion::at(index);
0634 }
0635 
0636 const char &SecureArray::at(int index) const
0637 {
0638     return MemoryRegion::at(index);
0639 }
0640 
0641 char *SecureArray::data()
0642 {
0643     return MemoryRegion::data();
0644 }
0645 
0646 const char *SecureArray::data() const
0647 {
0648     return MemoryRegion::data();
0649 }
0650 
0651 const char *SecureArray::constData() const
0652 {
0653     return MemoryRegion::constData();
0654 }
0655 
0656 int SecureArray::size() const
0657 {
0658     return MemoryRegion::size();
0659 }
0660 
0661 bool SecureArray::isEmpty() const
0662 {
0663     return MemoryRegion::isEmpty();
0664 }
0665 
0666 QByteArray SecureArray::toByteArray() const
0667 {
0668     return MemoryRegion::toByteArray();
0669 }
0670 
0671 SecureArray &SecureArray::append(const SecureArray &a)
0672 {
0673     const int oldsize = size();
0674     resize(oldsize + a.size());
0675     memcpy(data() + oldsize, a.data(), a.size());
0676     return *this;
0677 }
0678 
0679 bool SecureArray::operator==(const MemoryRegion &other) const
0680 {
0681     if (this == &other)
0682         return true;
0683     if (size() == other.size() && memcmp(data(), other.data(), size()) == 0)
0684         return true;
0685     return false;
0686 }
0687 
0688 SecureArray &SecureArray::operator+=(const SecureArray &a)
0689 {
0690     return append(a);
0691 }
0692 
0693 void SecureArray::fill(char fillChar, int fillToPosition)
0694 {
0695     const int len = (fillToPosition == -1) ? size() : qMin(fillToPosition, size());
0696     if (len > 0)
0697         memset(data(), (int)fillChar, len);
0698 }
0699 
0700 void SecureArray::set(const SecureArray &from)
0701 {
0702     *this = from;
0703 }
0704 
0705 void SecureArray::set(const QByteArray &from)
0706 {
0707     *this = from;
0708 }
0709 
0710 const SecureArray operator+(const SecureArray &a, const SecureArray &b)
0711 {
0712     SecureArray c = a;
0713     return c.append(b);
0714 }
0715 
0716 //----------------------------------------------------------------------------
0717 // BigInteger
0718 //----------------------------------------------------------------------------
0719 static void negate_binary(char *a, int size)
0720 {
0721     // negate = two's compliment + 1
0722     bool done = false;
0723     for (int n = size - 1; n >= 0; --n) {
0724         a[n] = ~a[n];
0725         if (!done) {
0726             if ((unsigned char)a[n] < 0xff) {
0727                 ++a[n];
0728                 done = true;
0729             } else
0730                 a[n] = 0;
0731         }
0732     }
0733 }
0734 
0735 class BigInteger::Private : public QSharedData
0736 {
0737 public:
0738     Botan::BigInt n;
0739 };
0740 
0741 BigInteger::BigInteger()
0742 {
0743     d = new Private;
0744 }
0745 
0746 BigInteger::BigInteger(int i)
0747 {
0748     d = new Private;
0749     if (i < 0) {
0750         d->n = Botan::BigInt(i * (-1));
0751         d->n.set_sign(Botan::BigInt::Negative);
0752     } else {
0753         d->n = Botan::BigInt(i);
0754         d->n.set_sign(Botan::BigInt::Positive);
0755     }
0756 }
0757 
0758 BigInteger::BigInteger(const char *c)
0759 {
0760     d = new Private;
0761     fromString(QString::fromLatin1(c));
0762 }
0763 
0764 BigInteger::BigInteger(const QString &s)
0765 {
0766     d = new Private;
0767     fromString(s);
0768 }
0769 
0770 BigInteger::BigInteger(const SecureArray &a)
0771 {
0772     d = new Private;
0773     fromArray(a);
0774 }
0775 
0776 BigInteger::BigInteger(const BigInteger &from)
0777 {
0778     *this = from;
0779 }
0780 
0781 BigInteger::~BigInteger()
0782 {
0783 }
0784 
0785 BigInteger &BigInteger::operator=(const BigInteger &from)
0786 {
0787     d = from.d;
0788     return *this;
0789 }
0790 
0791 BigInteger &BigInteger::operator+=(const BigInteger &i)
0792 {
0793     d->n += i.d->n;
0794     return *this;
0795 }
0796 
0797 BigInteger &BigInteger::operator-=(const BigInteger &i)
0798 {
0799     d->n -= i.d->n;
0800     return *this;
0801 }
0802 
0803 BigInteger &BigInteger::operator*=(const BigInteger &i)
0804 {
0805     d->n *= i.d->n;
0806     return *this;
0807 }
0808 
0809 BigInteger &BigInteger::operator/=(const BigInteger &i)
0810 {
0811     try {
0812         d->n /= i.d->n;
0813     } catch (std::exception &) {
0814         fprintf(stderr, "QCA: Botan integer division error\n");
0815         abort();
0816     }
0817     return *this;
0818 }
0819 
0820 BigInteger &BigInteger::operator%=(const BigInteger &i)
0821 {
0822     try {
0823         d->n %= i.d->n;
0824     } catch (std::exception &) {
0825         fprintf(stderr, "QCA: Botan integer division error\n");
0826         abort();
0827     }
0828     return *this;
0829 }
0830 
0831 BigInteger &BigInteger::operator=(const QString &s)
0832 {
0833     fromString(s);
0834     return *this;
0835 }
0836 
0837 int BigInteger::compare(const BigInteger &n) const
0838 {
0839     return ((d->n).cmp(n.d->n, true));
0840 }
0841 
0842 QTextStream &operator<<(QTextStream &stream, const BigInteger &b)
0843 {
0844     stream << b.toString();
0845     return stream;
0846 }
0847 
0848 SecureArray BigInteger::toArray() const
0849 {
0850     int size = d->n.encoded_size(Botan::BigInt::Binary);
0851 
0852     // return at least 8 bits
0853     if (size == 0) {
0854         SecureArray a(1);
0855         a[0] = 0;
0856         return a;
0857     }
0858 
0859     int         offset = 0;
0860     SecureArray a;
0861 
0862     // make room for a sign bit if needed
0863     if (d->n.get_bit((size * 8) - 1)) {
0864         ++size;
0865         a.resize(size);
0866         a[0] = 0;
0867         ++offset;
0868     } else
0869         a.resize(size);
0870 
0871     Botan::BigInt::encode((Botan::byte *)a.data() + offset, d->n, Botan::BigInt::Binary);
0872 
0873     if (d->n.is_negative())
0874         negate_binary(a.data(), a.size());
0875 
0876     return a;
0877 }
0878 
0879 void BigInteger::fromArray(const SecureArray &_a)
0880 {
0881     if (_a.isEmpty()) {
0882         d->n = Botan::BigInt(0);
0883         return;
0884     }
0885     SecureArray a = _a;
0886 
0887     Botan::BigInt::Sign sign = Botan::BigInt::Positive;
0888     if (a[0] & 0x80)
0889         sign = Botan::BigInt::Negative;
0890 
0891     if (sign == Botan::BigInt::Negative)
0892         negate_binary(a.data(), a.size());
0893 
0894     d->n = Botan::BigInt::decode((const Botan::byte *)a.data(), a.size(), Botan::BigInt::Binary);
0895     d->n.set_sign(sign);
0896 }
0897 
0898 QString BigInteger::toString() const
0899 {
0900     QByteArray cs;
0901     try {
0902         cs.resize(d->n.encoded_size(Botan::BigInt::Decimal));
0903         Botan::BigInt::encode((Botan::byte *)cs.data(), d->n, Botan::BigInt::Decimal);
0904     } catch (std::exception &) {
0905         return QString();
0906     }
0907 
0908     QString str;
0909     if (d->n.is_negative())
0910         str += QLatin1Char('-');
0911     str += QString::fromLatin1(cs);
0912     str.remove(QChar::Null);
0913     return str;
0914 }
0915 
0916 bool BigInteger::fromString(const QString &s)
0917 {
0918     if (s.isEmpty())
0919         return false;
0920     const QByteArray cs = s.toLatin1();
0921 
0922     bool neg = false;
0923     if (s[0] == QLatin1Char('-'))
0924         neg = true;
0925 
0926     try {
0927         d->n = Botan::BigInt::decode(
0928             (const Botan::byte *)cs.data() + (neg ? 1 : 0), cs.length() - (neg ? 1 : 0), Botan::BigInt::Decimal);
0929     } catch (std::exception &) {
0930         return false;
0931     }
0932 
0933     if (neg)
0934         d->n.set_sign(Botan::BigInt::Negative);
0935     else
0936         d->n.set_sign(Botan::BigInt::Positive);
0937     return true;
0938 }
0939 
0940 }