private byte[] processCertReq(
String username,
String password,
String req, // NOPMD
int reqType,
String hardTokenSN,
String responseType) // NOPMD
throws EjbcaException_Exception, AuthorizationDeniedException_Exception {
try {
final byte[] retval;
UserDataVOWS userdata = findUser(username);
if (userdata == null) {
EjbcaException ex = new EjbcaException();
ErrorCode code = new ErrorCode();
// code.setInternalErrorCode(todo)
ex.setErrorCode(code);
throw new EjbcaException_Exception("User not found: " + username, ex);
}
// String caName = userdata.getCaName();
pkcs10req = RequestMessageUtils.genPKCS10RequestMessage(req.getBytes());
PublicKey pubKey = pkcs10req.getRequestPublicKey();
// IRequestMessage imsg = new SimpleRequestMessage(pubKey, username,
// password);
X509Certificate cert = ca.issueCertificate(userdata.getSubjectDN(), 5, "SHA1withRSA", pubKey);
if (RESPONSETYPE_PKCS7WITHCHAIN.equals(responseType)) {
retval = ca.createPKCS7(cert, true);
} else {
// retval = cert.getEncoded();
throw new UnsupportedOperationException("Not supported yet");
}
// Set to generated
userdata.setStatus(40);
return retval;
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
/**
* Mock implementation of the EJBCA Web Service.
*
* @author Markus Kilås
* @version $Id$
*/
@WebService(
serviceName = "EjbcaWSService",
portName = "EjbcaWSPort",
targetNamespace = "http://ws.protocol.core.ejbca.org/",
endpointInterface = "org.signserver.module.renewal.ejbcaws.gen.EjbcaWS")
public class MockEjbcaWS {
/** Logger for this class. */
private static final Logger LOG = Logger.getLogger(MockEjbcaWS.class);
private boolean findUserCalled;
private boolean editUserCalled;
private boolean pkcs10RequestCalled;
private boolean authenticationFail;
private Map<UserMatchEq, List<UserDataVOWS>> findUserResults = Collections.emptyMap();
private MockCA ca = MockCA.createMockCA("CN=MockupRootCA,O=SignServer Testing,C=SE");
private PKCS10RequestMessage pkcs10req;
// From CertificateHelper:
/**
* Indicates that the requester want a BASE64 encoded certificate in the CertificateResponse
* object.
*/
// private static String RESPONSETYPE_CERTIFICATE = "CERTIFICATE";
/** Indicates that the requester want a BASE64 encoded pkcs7 in the CertificateResponse object. */
// private static String RESPONSETYPE_PKCS7 = "PKCS7";
/**
* Indicates that the requester want a BASE64 encoded pkcs7 with the complete chain in the
* CertificateResponse object.
*/
private static String RESPONSETYPE_PKCS7WITHCHAIN = "PKCS7WITHCHAIN";
public Certificate getCertificate(String arg0, String arg1)
throws AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception {
throw new UnsupportedOperationException("Not supported yet.");
}
public boolean isAuthorized(String arg0) throws EjbcaException_Exception {
System.out.println("arg0: " + arg0);
return !authenticationFail;
}
public int isApproved(int arg0)
throws ApprovalException_Exception, ApprovalRequestExpiredException_Exception,
EjbcaException_Exception {
throw new UnsupportedOperationException("Not supported yet.");
}
public boolean existsHardToken(String arg0) throws EjbcaException_Exception {
throw new UnsupportedOperationException("Not supported yet.");
}
public List<NameAndId> getAvailableCAs()
throws AuthorizationDeniedException_Exception, EjbcaException_Exception {
throw new UnsupportedOperationException("Not supported yet.");
}
public void revokeUser(String arg0, int arg1, boolean arg2)
throws AlreadyRevokedException_Exception, ApprovalException_Exception,
AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception, NotFoundException_Exception,
WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public void revokeCert(String arg0, String arg1, int arg2)
throws AlreadyRevokedException_Exception, ApprovalException_Exception,
AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception, NotFoundException_Exception,
WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public List<UserDataVOWS> findUser(UserMatch arg0)
throws AuthorizationDeniedException_Exception, EjbcaException_Exception,
IllegalQueryException_Exception {
checkAuth();
List<UserDataVOWS> result = findUserResults.get(new UserMatchEq(arg0));
return result;
}
public void createCRL(String arg0)
throws ApprovalException_Exception, ApprovalRequestExpiredException_Exception,
CADoesntExistsException_Exception, EjbcaException_Exception {
throw new UnsupportedOperationException("Not supported yet.");
}
public void editUser(UserDataVOWS arg0)
throws ApprovalException_Exception, AuthorizationDeniedException_Exception,
CADoesntExistsException_Exception, EjbcaException_Exception,
UserDoesntFullfillEndEntityProfile_Exception, WaitingForApprovalException_Exception {
checkAuth();
System.out.println("editUser(" + arg0 + ")");
editUserCalled = true;
}
public List<Certificate> findCerts(String arg0, boolean arg1)
throws AuthorizationDeniedException_Exception, EjbcaException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public List<Certificate> getLastCertChain(String arg0)
throws AuthorizationDeniedException_Exception, EjbcaException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public CertificateResponse crmfRequest(
String arg0, String arg1, String arg2, String arg3, String arg4)
throws AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception, NotFoundException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public CertificateResponse spkacRequest(
String arg0, String arg1, String arg2, String arg3, String arg4)
throws AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception, NotFoundException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public List<Certificate> cvcRequest(String arg0, String arg1, String arg2)
throws ApprovalException_Exception, AuthorizationDeniedException_Exception,
CADoesntExistsException_Exception, CertificateExpiredException_Exception,
EjbcaException_Exception, NotFoundException_Exception, SignRequestException_Exception,
UserDoesntFullfillEndEntityProfile_Exception, WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public byte[] caRenewCertRequest(
String arg0, List<byte[]> arg1, boolean arg2, boolean arg3, boolean arg4, String arg5)
throws ApprovalException_Exception, AuthorizationDeniedException_Exception,
CADoesntExistsException_Exception, EjbcaException_Exception,
WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public void caCertResponse(String arg0, byte[] arg1, List<byte[]> arg2, String arg3)
throws ApprovalException_Exception, AuthorizationDeniedException_Exception,
CADoesntExistsException_Exception, EjbcaException_Exception,
WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public CertificateResponse pkcs10Request(
String username, String password, String pkcs10, String hardTokenSN, String responseType)
throws AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception, NotFoundException_Exception {
checkAuth();
System.out.println(">certificateRequest");
pkcs10RequestCalled = true;
final CertificateResponse result = new CertificateResponse();
LOG.debug("PKCS10 from user '" + username + "'.");
result.setResponseType(responseType);
result.setData(
Base64.encode(processCertReq(username, password, pkcs10, 0, hardTokenSN, responseType)));
return result;
}
private byte[] processCertReq(
String username,
String password,
String req, // NOPMD
int reqType,
String hardTokenSN,
String responseType) // NOPMD
throws EjbcaException_Exception, AuthorizationDeniedException_Exception {
try {
final byte[] retval;
UserDataVOWS userdata = findUser(username);
if (userdata == null) {
EjbcaException ex = new EjbcaException();
ErrorCode code = new ErrorCode();
// code.setInternalErrorCode(todo)
ex.setErrorCode(code);
throw new EjbcaException_Exception("User not found: " + username, ex);
}
// String caName = userdata.getCaName();
pkcs10req = RequestMessageUtils.genPKCS10RequestMessage(req.getBytes());
PublicKey pubKey = pkcs10req.getRequestPublicKey();
// IRequestMessage imsg = new SimpleRequestMessage(pubKey, username,
// password);
X509Certificate cert = ca.issueCertificate(userdata.getSubjectDN(), 5, "SHA1withRSA", pubKey);
if (RESPONSETYPE_PKCS7WITHCHAIN.equals(responseType)) {
retval = ca.createPKCS7(cert, true);
} else {
// retval = cert.getEncoded();
throw new UnsupportedOperationException("Not supported yet");
}
// Set to generated
userdata.setStatus(40);
return retval;
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
private UserDataVOWS findUser(final String username)
throws AuthorizationDeniedException_Exception, EjbcaException_Exception {
try {
final UserMatchEq match1 = new UserMatchEq();
match1.setMatchwith(RenewalWorkerTest.MATCH_WITH_USERNAME);
match1.setMatchtype(RenewalWorkerTest.MATCH_TYPE_EQUALS);
match1.setMatchvalue(username);
List<UserDataVOWS> users = findUser(match1);
if (users.size() < 1) {
return null;
} else {
return users.get(0);
}
} catch (IllegalQueryException_Exception ex) {
throw new RuntimeException(ex);
}
}
public KeyStore pkcs12Req(String arg0, String arg1, String arg2, String arg3, String arg4)
throws AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception, NotFoundException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public void keyRecoverNewest(String arg0)
throws ApprovalException_Exception, AuthorizationDeniedException_Exception,
CADoesntExistsException_Exception, EjbcaException_Exception, NotFoundException_Exception,
WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public void revokeToken(String arg0, int arg1)
throws AlreadyRevokedException_Exception, ApprovalException_Exception,
AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception, NotFoundException_Exception,
WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public RevokeStatus checkRevokationStatus(String arg0, String arg1)
throws AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public List<UserDataSourceVOWS> fetchUserData(List<String> arg0, String arg1)
throws AuthorizationDeniedException_Exception, EjbcaException_Exception,
UserDataSourceException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public List<TokenCertificateResponseWS> genTokenCertificates(
UserDataVOWS arg0,
List<TokenCertificateRequestWS> arg1,
HardTokenDataWS arg2,
boolean arg3,
boolean arg4)
throws ApprovalException_Exception, ApprovalRequestExecutionException_Exception,
ApprovalRequestExpiredException_Exception, AuthorizationDeniedException_Exception,
CADoesntExistsException_Exception, EjbcaException_Exception,
HardTokenExistsException_Exception, UserDoesntFullfillEndEntityProfile_Exception,
WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public HardTokenDataWS getHardTokenData(String arg0, boolean arg1, boolean arg2)
throws ApprovalRequestExecutionException_Exception, ApprovalRequestExpiredException_Exception,
AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception, HardTokenDoesntExistsException_Exception,
NotFoundException_Exception, WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public List<HardTokenDataWS> getHardTokenDatas(String arg0, boolean arg1, boolean arg2)
throws AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public void republishCertificate(String arg0, String arg1)
throws AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception, PublisherException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public void customLog(
int arg0, String arg1, String arg2, String arg3, Certificate arg4, String arg5)
throws AuthorizationDeniedException_Exception, CADoesntExistsException_Exception,
EjbcaException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public boolean deleteUserDataFromSource(List<String> arg0, String arg1, boolean arg2)
throws AuthorizationDeniedException_Exception, EjbcaException_Exception,
MultipleMatchException_Exception, UserDataSourceException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public List<NameAndId> getAuthorizedEndEntityProfiles()
throws AuthorizationDeniedException_Exception, EjbcaException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public List<NameAndId> getAvailableCertificateProfiles(int arg0)
throws AuthorizationDeniedException_Exception, EjbcaException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public List<NameAndId> getAvailableCAsInProfile(int arg0)
throws AuthorizationDeniedException_Exception, EjbcaException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public String getEjbcaVersion() {
throw new UnsupportedOperationException("Not supported yet.");
}
public int getPublisherQueueLength(String arg0) throws EjbcaException_Exception {
throw new UnsupportedOperationException("Not supported yet.");
}
public CertificateResponse certificateRequest(
UserDataVOWS arg0, String arg1, int arg2, String arg3, String arg4)
throws ApprovalException_Exception, AuthorizationDeniedException_Exception,
CADoesntExistsException_Exception, EjbcaException_Exception, NotFoundException_Exception,
UserDoesntFullfillEndEntityProfile_Exception, WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
public KeyStore softTokenRequest(UserDataVOWS arg0, String arg1, String arg2, String arg3)
throws ApprovalException_Exception, AuthorizationDeniedException_Exception,
CADoesntExistsException_Exception, EjbcaException_Exception, NotFoundException_Exception,
UserDoesntFullfillEndEntityProfile_Exception, WaitingForApprovalException_Exception {
checkAuth();
throw new UnsupportedOperationException("Not supported yet.");
}
//////////////////////////////////////////////////////////////////////////
// Methods for controlling the mockup
public void resetCalls() {
editUserCalled = false;
pkcs10RequestCalled = false;
}
public boolean isFindUserCalled() {
return findUserCalled;
}
public boolean isPkcs10RequestCalled() {
return pkcs10RequestCalled;
}
public boolean isEditUserCalled() {
return editUserCalled;
}
public void setFindUserResults(Map<UserMatchEq, List<UserDataVOWS>> findUserResults) {
this.findUserResults = findUserResults;
}
public void setAuthenticationFail(final boolean authenticationFail) {
this.authenticationFail = authenticationFail;
}
private void checkAuth() throws AuthorizationDeniedException_Exception {
if (authenticationFail) {
AuthorizationDeniedException fault = new AuthorizationDeniedException();
fault.setMessage("Administrator not authorized to resource");
throw new AuthorizationDeniedException_Exception(
"Administrator not authorized to resource", fault);
}
}
public PKCS10RequestMessage getLastPKCS10() {
return pkcs10req;
}
}