Java ChallengeScheme类代码示例

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
@SubResource
public void administration()
{
    ChallengeResponse challenge = Request.getCurrent().getChallengeResponse();
    if( challenge == null )
    {
        Response.getCurrent()
            .setChallengeRequests( Collections.singletonList( new ChallengeRequest( ChallengeScheme.HTTP_BASIC, "Forum" ) ) );
        throw new ResourceException( Status.CLIENT_ERROR_UNAUTHORIZED );
    }

    User user = select( Users.class, Users.USERS_ID ).userNamed( challenge.getIdentifier() );
    if( user == null || !user.isCorrectPassword( new String( challenge.getSecret() ) ) )
    {
        throw new ResourceException( Status.CLIENT_ERROR_UNAUTHORIZED );
    }

    current().select( user );

    subResource( AdministrationResource.class );
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
public static void main( String[] args )
    throws Exception
{
    Energy4Java polygene = new Energy4Java(  );

    Server server = new Server( Protocol.HTTP, 8888 );

    Application app = polygene.newApplication( new ForumAssembler(), new MetadataService() );

    app.activate();

    ContextRestlet restlet = app.findModule( "REST", "Restlet" ).newObject( ContextRestlet.class, new org.restlet.Context() );

    ChallengeAuthenticator guard = new ChallengeAuthenticator(null, ChallengeScheme.HTTP_BASIC, "testRealm");
    MapVerifier mapVerifier = new MapVerifier();
    mapVerifier.getLocalSecrets().put("rickard", "secret".toCharArray());
    guard.setVerifier(mapVerifier);

    guard.setNext(restlet);

    server.setNext( restlet );
    server.start();
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
@Override
public List<Car> list() {
    Client client = new Client(new Context(), Protocol.HTTPS);
    Series<Parameter> parameters = client.getContext().getParameters();
    parameters.add("truststorePath", System.getProperty("javax.net.ssl.trustStore"));

    ClientResource clientResource = new ClientResource("https://localhost:8043/api/cars/cars");
    clientResource.setNext(client);
    ChallengeResponse challenge = new ChallengeResponse(ChallengeScheme.HTTP_OAUTH_BEARER);
    challenge.setRawValue(Request.getCurrent().getAttributes().getOrDefault("token", "").toString());
    clientResource.setChallengeResponse(challenge);
    CarServiceInterface carServiceInterface = clientResource.wrap(CarServiceInterface.class);
    Car[] allCars = carServiceInterface.getAllCars();
    try {
        client.stop();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return asList(allCars);
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
public void initializeAuthentication() {
	if(verifier == null){
		verifier = new DefaultSecretVerifier();
	}
	authenticator = new ChallengeAuthenticator(null, false, ChallengeScheme.HTTP_BASIC, "Foxbpm Realm") {
		protected boolean authenticate(Request request, Response response) {
			if (restAuthenticator != null && !restAuthenticator.requestRequiresAuthentication(request)) {
				return true;
			}
			if (request.getChallengeResponse() == null) {
				response.setStatus(Status.CLIENT_ERROR_UNAUTHORIZED);
				return false;
			} else {
				boolean authenticated = super.authenticate(request, response);
				if (authenticated && restAuthenticator != null) {
					authenticated = restAuthenticator.isRequestAuthorized(request);
				}
				return authenticated;
			}
		}
	};
	authenticator.setVerifier(verifier);
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
/**
 * @param args
 */
public static void main(String[] args) {
	ClientResource client = new ClientResource("http://localhost:8889/foxbpm-webapps-base/service/identity/allUsers");
	client.setChallengeResponse(ChallengeScheme.HTTP_BASIC, "111", "111");
	Representation result = client.get();
	try {
		BufferedReader br = new BufferedReader(result.getReader());
		String line = null;
		while ((line = br.readLine()) != null) {
			System.out.println(line);
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
	
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
static Response postMethodRWS(ConnectionProperties cp, String uriReference, Representation form) throws RancidApiException {
    
    client.setConnectTimeout(cp.getTimeout());
    client.setProtocols(cp.getProtocols());;

    Request request = new Request(Method.POST, uriReference, form);
    
    if(cp.getAuthOn()){
        
        ChallengeScheme scheme = ChallengeScheme.HTTP_BASIC;
        ChallengeResponse authentication = new ChallengeResponse(scheme,cp.getUserName(), cp.getPassword());
        

        request.setChallengeResponse(authentication);
    }
    else {
        
    }
    Response response = client.handle(request); 
    if (response.getStatus().isSuccess()) {
        return response;
    } else {
    	throw(handleException(response, "POST" ,uriReference));
    }
    
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
public OAuthEndpoint(final AbstractOAuthApplication application) {

        getDefaultHost().attachDefault(application);

        getClients().add(Protocol.FILE);
        getClients().add(Protocol.HTTP);
        getClients().add(Protocol.HTTPS);
        // Prevent warnings about unsupported authentication
        Engine.getInstance().getRegisteredAuthenticators()
                .add(new AuthenticatorHelper(ChallengeScheme.HTTP_OAUTH_BEARER, true, false) {
                });
    }
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
private HandlerCommand invokeQuery( Reference ref, Object queryRequest, ResponseHandler resourceHandler, ResponseHandler processingErrorHandler )
{
    Request request = new Request( Method.GET, ref );

    if( queryRequest != null )
    {
        contextResourceFactory.writeRequest( request, queryRequest );
    }

    contextResourceFactory.updateQueryRequest( request );

    User user = request.getClientInfo().getUser();
    if ( user != null)
        request.setChallengeResponse( new ChallengeResponse( ChallengeScheme.HTTP_BASIC, user.getName(), user.getSecret() ) );

    Response response = new Response( request );

    contextResourceFactory.getClient().handle( request, response );

    if( response.getStatus().isSuccess() )
    {
        contextResourceFactory.updateCache( response );

        return resourceHandler.handleResponse( response, this );
    } else if (response.getStatus().isRedirection())
    {
        Reference redirectedTo = response.getLocationRef();
        return invokeQuery( redirectedTo, queryRequest, resourceHandler, processingErrorHandler );
    } else
    {
        if (response.getStatus().equals(Status.CLIENT_ERROR_UNPROCESSABLE_ENTITY) && processingErrorHandler != null)
        {
            return processingErrorHandler.handleResponse( response, this );
        } else
        {
            // TODO This needs to be expanded to allow custom handling of all the various cases
            return errorHandler.handleResponse( response, this );
        }
    }
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
@Override
public Restlet createInboundRoot()
{
    Context context = getContext();
    Engine.getInstance().getRegisteredConverters().add( new PolygeneConverter( objectFactory ) );

    if( polygeneApplication.mode() == Application.Mode.development )
    {
        setDebugging( true );
    }
    router = new Router( context );

    addRoutes( router );
    router.attach( basePath, newPolygeneRestlet( EntryPointResource.class, EntryPoint.class ) );

    Verifier verifier = createVerifier();
    Enroler enroler = createEnroler();
    if( verifier == null && enroler == null )
    {
        return createInterceptors(new Filter()
            {
            } );
    }
    else
    {
        ChallengeAuthenticator guard = new ChallengeAuthenticator( context, ChallengeScheme.HTTP_BASIC, getName() + " Realm" );

        if( verifier != null )
        {
            guard.setVerifier( verifier );
        }

        if( enroler != null )
        {
            guard.setEnroler( enroler );
        }
        return createInterceptors( guard );
    }
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    ClientResource resource = new ClientResource(REST_URI);

    // 设置Base Auth认证
    resource.setChallengeResponse(ChallengeScheme.HTTP_BASIC, "kermit", "kermit");

    Representation representation = resource.get();
    ObjectMapper mapper = new ObjectMapper();
    JsonNode jsonNode = mapper.readTree(representation.getStream());
    Iterator<String> fieldNames = jsonNode.fieldNames();
    while (fieldNames.hasNext()) {
        String fieldName = fieldNames.next();
        System.out.println(fieldName + " : " + jsonNode.get(fieldName));
    }
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
private ChallengeAuthenticator getAdminGuard() {
        // Create a simple password verifier
//        MapVerifier verifier = new MapVerifier();
//        verifier.getLocalSecrets().put("mitko", "qwepoi".toCharArray());

        // Create a guard
        ChallengeAuthenticator guard = new ChallengeAuthenticator(getContext(),
                ChallengeScheme.HTTP_BASIC, "FP Admin");
        guard.setVerifier(new AdminVerifier());
        return guard;
    }
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
private ChallengeAuthenticator getUserGuard() {
    // Create a guard
    ChallengeAuthenticator guard = new ChallengeAuthenticator(getContext(),
            ChallengeScheme.HTTP_BASIC, "FP User");
    guard.setVerifier(new UserVerifier());
    guard.setOptional(getAppProperties().getProperty("DisableAnonymous", "1").equals("1")?false:true);
    return guard;
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
private ChallengeAuthenticator createAuthenticator() {
    ChallengeAuthenticator auth= new ChallengeAuthenticator(null, ChallengeScheme.HTTP_BASIC, "mcrest");
    MapVerifier mapVerifier = new MapVerifier();
    mapVerifier.getLocalSecrets().put(authpara.getUserId(), authpara.getPassword().toCharArray());
    auth.setVerifier(mapVerifier);
    return auth;
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
private Response getRequestResultWithAuth(String path,String user,String password){
    Request request = new Request(Method.GET, serverUrl+path);
    Client client = new Client(Protocol.HTTP);

    ChallengeResponse authentication = new ChallengeResponse(
            ChallengeScheme.HTTP_BASIC, user, password);
    request.setChallengeResponse(authentication);

    Response response = client.handle(request);
    return response;
}
 

import org.restlet.data.ChallengeScheme; //导入依赖的package包/类
@Override
public int verify(Request request, Response response) {
    final String token;

    try {
        ChallengeResponse cr = request.getChallengeResponse();
        if (cr == null) {
            return RESULT_MISSING;
        } else if (ChallengeScheme.HTTP_OAUTH_BEARER.equals(cr.getScheme())) {
            final String bearer = cr.getRawValue();
            if (bearer == null || bearer.isEmpty()) {
                return RESULT_MISSING;
            }
            token = bearer;
        } else {
            return RESULT_UNSUPPORTED;
        }
    } catch (Exception ex) {
        return RESULT_INVALID;
    }

    Try<User> user = accessTokenVerificationCommandFactory.createVerificationCommand(token).executeCommand();
    return user.map(u -> {
        org.restlet.security.User restletUser = createRestletUser(u);
        request.getClientInfo().setUser(restletUser);
        request.getAttributes().put("token", token);
        return RESULT_VALID;
    }).orElse(RESULT_INVALID);
}