void
Entry::setData(const Data& data, bool isUnsolicited, const ndn::ConstBufferPtr& digest)
{
m_dataPacket = data.shared_from_this();
m_digest = digest;
updateStaleTime();
m_nameWithDigest = data.getName();
m_nameWithDigest.append(ndn::name::Component(getDigest()));
}
/**
* Finish the hash calculation and free resources.
* @param context the hash context
* @param digest - the buffer to hold the digest.
* Must be NULL or of size AJ_SHA256_DIGEST_LENGTH.
* If the value is NULL, resources are freed but the digest
* is not calculated.
* @return AJ_OK if successful, otherwise error.
*/
AJ_Status AJ_SHA256_Final(AJ_SHA256_Context* context, uint8_t* digest)
{
AJ_Status status = AJ_OK;
if (!digest) {
AJ_MemZeroSecure(context, sizeof(*context));
AJ_Free(context);
} else {
status = getDigest(context, digest, 0);
}
return status;
}
int main(int argc, char* argv[])
{
if(argc != 3)
{
fprintf(stderr, "Usage: %s <keyfile> <server_ip>\n", argv[0]);
return 1;
}
int res = readKey(argv[1]);
if(res) return 2;
char* ip = argv[2];
sock = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(SERVER_PORT);
sa.sin_addr.s_addr = inet_addr(ip);
if(connect(sock, (struct sockaddr*)&sa, sizeof(sa))==-1)
{
perror("connect");
return 3;
}
uint8_t challenge[CHALLENGE_SIZE];
int len = recv(sock, challenge, sizeof(challenge), 0);
if(len<=0)
{
perror("recv");
return 4;
}
if(len!=sizeof(challenge))
{
fprintf(stderr, "short challenge\n");
return 5;
}
uint8_t digest[20];
getDigest(digest, challenge, sizeof(challenge));
send(sock, digest, sizeof(digest), 0);
while(!feof(stdin))
{
if(loop()<0) break;
}
return 0;
}
SHA256Block getLogicalSessionUserDigestForLoggedInUser(const OperationContext* opCtx) {
auto client = opCtx->getClient();
ServiceContext* serviceContext = client->getServiceContext();
if (AuthorizationManager::get(serviceContext)->isAuthEnabled()) {
UserName userName;
const auto user = AuthorizationSession::get(client)->getSingleUser();
invariant(user);
return user->getDigest();
} else {
return kNoAuthDigest;
}
}
////////////////////////////////////////////////////////////////////////
// Md5stream
//
const char* Md5stream::getHexDigest()
{
static const char hexDigits[] = "0123456789abcdef";
unsigned char md5[16];
getDigest(md5);
int i;
char* p = hexdigest;
for (i = 0; i < 16; ++i)
{
*p++ = hexDigits[md5[i] >> 4];
*p++ = hexDigits[md5[i] & 0xf];
}
*p = '\0';
log_debug("md5: " << hexdigest);
return hexdigest;
}
LogicalSessionRecord makeLogicalSessionRecord(OperationContext* opCtx,
const LogicalSessionId& lsid,
Date_t lastUse) {
auto lsr = makeLogicalSessionRecord(lsid, lastUse);
auto client = opCtx->getClient();
ServiceContext* serviceContext = client->getServiceContext();
if (AuthorizationManager::get(serviceContext)->isAuthEnabled()) {
auto user = AuthorizationSession::get(client)->getSingleUser();
invariant(user);
if (user->getDigest() == lsid.getUid()) {
lsr.setUser(StringData(user->getName().toString()));
}
}
return lsr;
}
LogicalSessionRecord makeLogicalSessionRecord(OperationContext* opCtx, Date_t lastUse) {
LogicalSessionId id{};
LogicalSessionRecord lsr{};
auto client = opCtx->getClient();
ServiceContext* serviceContext = client->getServiceContext();
if (AuthorizationManager::get(serviceContext)->isAuthEnabled()) {
auto user = AuthorizationSession::get(client)->getSingleUser();
invariant(user);
id.setUid(user->getDigest());
lsr.setUser(StringData(user->getName().toString()));
} else {
id.setUid(kNoAuthDigest);
}
id.setId(UUID::gen());
lsr.setId(id);
lsr.setLastUse(lastUse);
return lsr;
}
void createUser(char* username, char* password, int randomDataFd, int outputFd)
{
unsigned char salt[SALT_LEN];
unsigned char digest[SHA256_DIGEST_LENGTH];
unsigned char hmac[SHA256_DIGEST_LENGTH];
ssize_t nByte;
getSalt(salt, randomDataFd);
getDigest(digest, salt, password);
getHMAC(hmac, digest);
nByte = write(outputFd, username, strlen(username));
nByte = write(outputFd, "|", 1);
nByte = write(outputFd, salt, SALT_LEN);
nByte = write(outputFd, "|", 1);
nByte = write(outputFd, digest, SHA256_DIGEST_LENGTH);
nByte = write(outputFd, "|", 1);
nByte = write(outputFd, hmac, SHA256_DIGEST_LENGTH);
nByte = write(outputFd, "\n", 1);
printf("User %s is created!\n", username);
printf("---------------------------------------------------------\n");
}
void Server::update() {
if (!((! qsRegName.isEmpty()) && (! qsRegName.isEmpty()) && (! qsRegPassword.isEmpty()) && qurlRegWeb.isValid() && qsPassword.isEmpty() && bAllowPing))
return;
// When QNAM distinguishes connections by client cert, move this to Meta
if (! qnamNetwork)
qnamNetwork = new QNetworkAccessManager(this);
qtTick.start(1000 * (60 * 60 + (qrand() % 300)));
QDomDocument doc;
QDomElement root=doc.createElement(QLatin1String("server"));
doc.appendChild(root);
OSInfo::fillXml(doc, root, meta->qsOS, meta->qsOSVersion, qlBind);
QDomElement tag;
QDomText t;
tag=doc.createElement(QLatin1String("name"));
root.appendChild(tag);
t=doc.createTextNode(qsRegName);
tag.appendChild(t);
tag=doc.createElement(QLatin1String("host"));
root.appendChild(tag);
t=doc.createTextNode(qsRegHost);
tag.appendChild(t);
tag=doc.createElement(QLatin1String("password"));
root.appendChild(tag);
t=doc.createTextNode(qsRegPassword);
tag.appendChild(t);
tag=doc.createElement(QLatin1String("port"));
root.appendChild(tag);
t=doc.createTextNode(QString::number(usPort));
tag.appendChild(t);
tag=doc.createElement(QLatin1String("url"));
root.appendChild(tag);
t=doc.createTextNode(qurlRegWeb.toString());
tag.appendChild(t);
tag=doc.createElement(QLatin1String("digest"));
root.appendChild(tag);
t=doc.createTextNode(getDigest());
tag.appendChild(t);
tag=doc.createElement(QLatin1String("users"));
root.appendChild(tag);
t=doc.createTextNode(QString::number(qhUsers.count()));
tag.appendChild(t);
tag=doc.createElement(QLatin1String("channels"));
root.appendChild(tag);
t=doc.createTextNode(QString::number(qhChannels.count()));
tag.appendChild(t);
QNetworkRequest qnr(QUrl(QLatin1String("https://mumble.hive.no/register.cgi")));
qnr.setHeader(QNetworkRequest::ContentTypeHeader, QLatin1String("text/xml"));
QSslConfiguration ssl = qnr.sslConfiguration();
ssl.setLocalCertificate(qscCert);
ssl.setPrivateKey(qskKey);
/* Work around bug in QSslConfiguration */
QList<QSslCertificate> calist = ssl.caCertificates();
calist << QSslSocket::defaultCaCertificates();
calist << qscCert;
ssl.setCaCertificates(calist);
qnr.setSslConfiguration(ssl);
QNetworkReply *rep = qnamNetwork->post(qnr, doc.toString().toUtf8());
connect(rep, SIGNAL(finished()), this, SLOT(finished()));
connect(rep, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(regSslError(const QList<QSslError> &)));
}
/**
* Retrieve the digest but keep the hash active for further updates.
* @param context the hash context
* @param digest the buffer to hold the digest. Must be of size AJ_SHA256_DIGEST_LENGTH
* @return AJ_OK if successful, otherwise error.
*/
AJ_Status AJ_SHA256_GetDigest(AJ_SHA256_Context* context, uint8_t* digest)
{
return getDigest(context, digest, 1);
}
