gss.h

// Copyright (c) 1999-2018 David Muse
// See the COPYING file for more information.
 
#ifndef RUDIMENTS_GSS_H
#define RUDIMENTS_GSS_H
 
#include <rudiments/private/gssincludes.h>
 
class RUDIMENTS_DLLSPEC gss : public object {
        public:
                gss();
 
                ~gss();
 
                const char * const      *getAvailableMechanisms();
 
                static  bool    isSupported();
 
        #include <rudiments/private/gss.h>
};
 
 
class RUDIMENTS_DLLSPEC gssmechanism : public object {
        public:
                gssmechanism();
 
                ~gssmechanism();
 
                bool    open(const char *str);
 
                bool    open(const void *oid);
 
                const char      *getString();
 
                const void      *getObjectId();
 
                bool    close();
 
        #include <rudiments/private/gssmechanism.h>
};
 
 
class RUDIMENTS_DLLSPEC gsscredentials : public object {
        public:
                gsscredentials();
 
                ~gsscredentials();
 
                bool            setKeytab(const char *keytab);
 
                const char      *getKeytab();
 
                void            setDesiredLifetime(uint32_t desiredlifetime);
 
                uint32_t        getDesiredLifetime();
 
                void            addDesiredMechanism(gssmechanism *mech);
 
                void            removeDesiredMechanism(gssmechanism *mech);
 
                bool            inDesiredMechanisms(gssmechanism *mech);
 
                void            clearDesiredMechanisms();
 
                uint64_t        getDesiredMechanismCount();
 
                gssmechanism *getDesiredMechanism(uint64_t index);
 
 
                bool    acquireForService(const char *name);
 
                bool    acquireForUser(const char *name);
 
 
                bool    getAreAcquired();
 
 
                void    close();
 
 
                const char      *getName();
 
                uint32_t        getActualLifetime();
 
                bool            isInActualMechanisms(gssmechanism *mech);
 
                uint64_t        getActualMechanismCount();
 
                gssmechanism    *getActualMechanism(uint64_t index);
 
 
                uint32_t        getMajorStatus();
 
                uint32_t        getMinorStatus();
 
                const char      *getStatus();
 
                const char      *getGSSMajorStatus();
 
                const char      *getGSSMinorStatus();
 
                const char      *getMechanismMajorStatus();
 
                const char      *getMechanismMinorStatus();
 
 
                const void      *getCredentials();
 
        #include <rudiments/private/gsscredentials.h>
};
 
 
class RUDIMENTS_DLLSPEC gsscontext : public securitycontext {
        public:
                gsscontext();
 
                virtual ~gsscontext();
                
                void    setCredentials(gsscredentials *credentials);
 
                gsscredentials  *getCredentials();
 
                void    setFileDescriptor(filedescriptor *fd);
 
                filedescriptor  *getFileDescriptor();
 
                void    setDesiredLifetime(uint32_t desiredlifetime);
 
                uint32_t        getDesiredLifetime();
 
                void    setDesiredMechanism(gssmechanism *desiredmechanism);
 
                gssmechanism    *getDesiredMechanism();
 
                void    setDesiredFlags(uint32_t desiredflags);
 
                void    setDesiredFlags(const char *desiredflags);
 
                uint32_t        getDesiredFlags();
 
                void    setService(const char *service);
 
                const char      *getService();
 
 
                bool    connect();
 
 
                bool    accept();
 
 
                uint32_t        getActualLifetime();
 
                gssmechanism    *getActualMechanism();
 
                uint32_t        getActualFlags();
 
                uint32_t        getRemainingLifetime();
 
 
                const char      *getInitiator();
 
                const char      *getAcceptor();
 
 
                bool    isInitiator();
 
                bool    isOpen();
 
 
                bool    wrap(const byte_t *input,
                                        size_t inputsize,
                                        byte_t **output,
                                        size_t *outputsize);
 
                bool    wrap(const byte_t *input,
                                        size_t inputsize,
                                        bool useencryption,
                                        byte_t **output,
                                        size_t *outputsize,
                                        bool *encryptionused);
 
 
                bool    unwrap(const byte_t *input,
                                        size_t inputsize,
                                        byte_t **output,
                                        size_t *outputsize);
 
                bool    unwrap(const byte_t *input,
                                        size_t inputsize,
                                        byte_t **output,
                                        size_t *outputsize,
                                        bool *decryptionused);
 
 
                bool    getMic(const byte_t *message,
                                        size_t messagesize,
                                        byte_t **mic,
                                        size_t *micsize);
 
                bool    verifyMic(const byte_t *message,
                                        size_t messagesize,
                                        const byte_t *mic,
                                        size_t micsize);
 
 
                ssize_t read(void *buf, size_t size);
 
                ssize_t write(const void *buf, size_t size);
 
                size_t getPendingSize();
 
 
                bool    close();
 
 
                size_t  getSizeMax();
 
 
                uint32_t        getMajorStatus();
 
                uint32_t        getMinorStatus();
 
                const char      *getStatus();
 
                const char      *getGSSMajorStatus();
 
                const char      *getGSSMinorStatus();
 
                const char      *getMechanismMajorStatus();
 
                const char      *getMechanismMinorStatus();
                
        #include <rudiments/private/gsscontext.h>
};
 
#endif