├── .gitattributes
├── settings.gradle
├── test
    ├── libs
    │   └── test.exp
    └── src
    │   └── main
    │       └── java
    │           └── fr
    │               └── bmartel
    │                   └── javacard
    │                       ├── HelloWorld.java
    │                       └── HelloWorld2.java
├── .gitmodules
├── gradle
    ├── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
    └── old.gradle
├── gradle-javacard
    ├── src
    │   ├── main
    │   │   ├── resources
    │   │   │   └── META-INF
    │   │   │   │   └── gradle-plugins
    │   │   │   │       └── javacard.properties
    │   │   └── groovy
    │   │   │   └── com
    │   │   │       └── klinec
    │   │   │           └── gradle
    │   │   │               └── javacard
    │   │   │                   ├── extension
    │   │   │                       ├── TestDependencies.groovy
    │   │   │                       ├── Test.groovy
    │   │   │                       ├── Script.groovy
    │   │   │                       ├── Task.groovy
    │   │   │                       ├── Import.groovy
    │   │   │                       ├── Applet.groovy
    │   │   │                       ├── Key.groovy
    │   │   │                       ├── Dependencies.groovy
    │   │   │                       ├── Scripts.groovy
    │   │   │                       ├── JavaCard.groovy
    │   │   │                       ├── Cap.groovy
    │   │   │                       └── Config.groovy
    │   │   │                   ├── gp
    │   │   │                       └── GpExec.groovy
    │   │   │                   ├── util
    │   │   │                       ├── SdkUtils.groovy
    │   │   │                       └── Utility.groovy
    │   │   │                   ├── JavaCardBuildTask.groovy
    │   │   │                   └── JavaCardPlugin.groovy
    │   └── test
    │   │   └── groovy
    │   │       └── com
    │   │           └── klinec
    │   │               └── gradle
    │   │                   └── javacard
    │   │                       ├── JavaCardGpExecTest.groovy
    │   │                       ├── JavaCardListTest.groovy
    │   │                       ├── JavaCardKeyTest.groovy
    │   │                       ├── JavaCardInstallTaskTest.groovy
    │   │                       ├── utils
    │   │                           └── TestUtils.groovy
    │   │                       ├── UtilityTest.groovy
    │   │                       ├── JavaCardScriptTest.groovy
    │   │                       ├── common
    │   │                           └── CommonTest.groovy
    │   │                       ├── JavaCardBuildTaskTest.groovy
    │   │                       ├── JavaCardPluginTest.groovy
    │   │                       └── StaticConfig.groovy
    └── build.gradle
├── .travis.yml
├── .gitignore
├── LICENSE.md
├── CHANGELOG.md
├── gradlew.bat
├── gradlew
└── README.md


/.gitattributes:
--------------------------------------------------------------------------------
1 | test/src/* linguist-vendored
2 | 


--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':gradle-javacard'
2 | 
3 | 


--------------------------------------------------------------------------------
/test/libs/test.exp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ph4r05/javacard-gradle-plugin/HEAD/test/libs/test.exp


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "sdks"]
2 | 	path = sdks
3 | 	url = git://github.com/martinpaljak/oracle_javacard_sdks.git
4 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ph4r05/javacard-gradle-plugin/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/gradle-javacard/src/main/resources/META-INF/gradle-plugins/javacard.properties:
--------------------------------------------------------------------------------
1 | implementation-class=com.klinec.gradle.javacard.JavaCardPlugin
2 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | dist: trusty
2 | language: java
3 | script: 
4 | - git submodule update --init --recursive
5 | - ./gradlew build jacocoTestReport
6 | jdk: oraclejdk8
7 | after_success:
8 | - ./gradlew jacocoRootReport coveralls
9 | 


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Fri Aug 11 02:05:15 CEST 2017
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | distributionUrl=https\://services.gradle.org/distributions/gradle-6.6-all.zip
7 | 


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/TestDependencies.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard.extension
 2 | 
 3 | class TestDependencies {
 4 | 
 5 |     /**
 6 |      * list of dependencies to compile.
 7 |      */
 8 |     List<Object> dependencies = []
 9 | 
10 |     void compile(Object dependency) {
11 |         dependencies.add(dependency)
12 |     }
13 | 
14 |     void implementation(Object dependency) {
15 |         dependencies.add(dependency)
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # built application files
 2 | *.apk
 3 | *.ap_
 4 | 
 5 | # files for the dex VM
 6 | *.dex
 7 | 
 8 | # Java class files
 9 | *.class
10 | 
11 | # generated files
12 | bin/
13 | gen/
14 | 
15 | # Local configuration file (sdk path, etc)
16 | local.properties
17 | 
18 | # Eclipse project files
19 | .classpath
20 | .project
21 | 
22 | # Proguard folder generated by Eclipse
23 | proguard/
24 | 
25 | # Intellij project files
26 | *.iml
27 | *.ipr
28 | *.iws
29 | .idea/
30 | 
31 | #Gradle
32 | .gradletasknamecache
33 | .gradle/
34 | build/
35 | bin/
36 | 
37 | doc/
38 | out/
39 | 


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Test.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard.extension
 2 | 
 3 | import org.gradle.api.Action
 4 | import org.gradle.api.model.ObjectFactory
 5 | import org.gradle.util.ClosureBackedAction
 6 | 
 7 | import javax.inject.Inject
 8 | 
 9 | abstract class Test {
10 | 
11 |     TestDependencies dependencies
12 | 
13 |     void dependencies(Closure closure) {
14 |         dependencies(ClosureBackedAction.of(closure))
15 |     }
16 | 
17 |     void dependencies(Action<TestDependencies> action) {
18 |         def dependency = objectFactory.newInstance(TestDependencies)
19 |         action.execute(dependency)
20 |         dependencies = dependency
21 |         dependency
22 |     }
23 | 
24 |     @Inject
25 |     abstract ObjectFactory getObjectFactory()
26 | }
27 | 


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/JavaCardGpExecTest.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard
 2 | 
 3 | 
 4 | import com.klinec.gradle.javacard.common.CommonTest
 5 | import com.klinec.gradle.javacard.gp.GpExec
 6 | import org.gradle.api.tasks.JavaExec
 7 | import org.junit.Test
 8 | 
 9 | import static org.junit.Assert.assertEquals
10 | import static org.junit.Assert.assertTrue
11 | 
12 | class JavaCardGpExecTest extends CommonTest {
13 | 
14 |     @Test
15 |     void gpExecTest() {
16 |         JavaExec listTask = project.tasks.create(name: 'testTask', type: GpExec)
17 | 
18 |         assertTrue(listTask ? true : false)
19 |         assertTrue(listTask instanceof JavaExec)
20 |         assertTrue(listTask instanceof GpExec)
21 |         assertEquals(listTask.main, 'pro.javacard.gp.GPTool')
22 |     }
23 | }


--------------------------------------------------------------------------------
/test/src/main/java/fr/bmartel/javacard/HelloWorld.java:
--------------------------------------------------------------------------------
 1 | package fr.bmartel.javacard;
 2 | 
 3 | import javacard.framework.*;
 4 | 
 5 | public class HelloWorld extends Applet {
 6 | 
 7 |     private final static byte[] hello = {0x48, 0x65, 0x6c, 0x6c, 0x6f};
 8 | 
 9 |     public static void install(byte[] buffer, short offset, byte length) {
10 |         (new HelloWorld()).register();
11 |     }
12 | 
13 |     public void process(APDU apdu) {
14 |         byte[] buf = apdu.getBuffer();
15 | 
16 |         switch (buf[ISO7816.OFFSET_INS]) {
17 |             case 0x40:
18 |                 Util.arrayCopy(hello, (byte) 0, buf, ISO7816.OFFSET_CDATA, (byte) 5);
19 |                 apdu.setOutgoingAndSend(
20 |                         ISO7816.OFFSET_CDATA, (byte) 5);
21 |                 break;
22 |             case ISO7816.INS_SELECT:
23 |                 apdu.setOutgoingAndSend(
24 |                         ISO7816.OFFSET_CDATA, (byte) 5);
25 |                 break;
26 |             default:
27 |                 ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/src/main/java/fr/bmartel/javacard/HelloWorld2.java:
--------------------------------------------------------------------------------
 1 | package fr.bmartel.javacard;
 2 | 
 3 | import javacard.framework.*;
 4 | 
 5 | public class HelloWorld2 extends Applet {
 6 | 
 7 |     private final static byte[] hello = {0x48, 0x65, 0x6c, 0x6c, 0x6f};
 8 | 
 9 |     public static void install(byte[] buffer, short offset, byte length) {
10 |         (new HelloWorld2()).register();
11 |     }
12 | 
13 |     public void process(APDU apdu) {
14 |         byte[] buf = apdu.getBuffer();
15 | 
16 |         switch (buf[ISO7816.OFFSET_INS]) {
17 |             case 0x40:
18 |                 Util.arrayCopy(hello, (byte) 0, buf, ISO7816.OFFSET_CDATA, (byte) 5);
19 |                 apdu.setOutgoingAndSend(
20 |                         ISO7816.OFFSET_CDATA, (byte) 5);
21 |                 break;
22 |             case ISO7816.INS_SELECT:
23 |                 apdu.setOutgoingAndSend(
24 |                         ISO7816.OFFSET_CDATA, (byte) 5);
25 |                 break;
26 |             default:
27 |                 ISOException.throwIt(ISO7816.SW_INS_NOT_SUPPORTED);
28 |         }
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2017-2018 Bertrand Martel
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/JavaCardListTest.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard
 2 | 
 3 | import com.klinec.gradle.javacard.common.CommonTest
 4 | import org.gradle.api.tasks.JavaExec
 5 | import org.junit.Test
 6 | 
 7 | import static org.junit.Assert.assertEquals
 8 | import static org.junit.Assert.assertTrue
 9 | 
10 | class JavaCardListTest extends CommonTest {
11 | 
12 |     @Test
13 |     void listAppletTest() {
14 |         runBuildTask(StaticConfig.VALID_CONFIG)
15 | 
16 |         JavaExec listTask = project.getTasks().findByName('listJavaCard')
17 | 
18 |         assertTrue(listTask ? true : false)
19 |         assertTrue(listTask instanceof JavaExec)
20 |         assertEquals(listTask.group, 'global platform')
21 |         assertEquals(listTask.args, ['-l',
22 |                                      '--key-enc', '404142434445464748494A4B4C4D4E4F',
23 |                                      '--key-mac', '404142434445464748494A4B4C4D4E4F',
24 |                                      '--key-dek', '404142434445464748494A4B4C4D4E4F'])
25 |         assertEquals(listTask.main, 'pro.javacard.gp.GPTool')
26 | 
27 |         //listTask.exec()
28 |     }
29 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/JavaCardKeyTest.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard
 2 | 
 3 | import com.klinec.gradle.javacard.common.CommonTest
 4 | import org.gradle.api.tasks.JavaExec
 5 | import org.junit.Test
 6 | 
 7 | import static org.junit.Assert.assertEquals
 8 | import static org.junit.Assert.assertTrue
 9 | 
10 | class JavaCardKeyTest extends CommonTest {
11 | 
12 |     @Test
13 |     void buildInstallMixedKey() {
14 |         runBuildTask(StaticConfig.VALID_CONFIG_MIXED_KEY)
15 |         JavaExec installTask = project.getTasks().getByName("installJavaCard")
16 |         assertTrue(installTask ? true : false)
17 |         assertTrue(installTask instanceof JavaExec)
18 |         assertEquals('global platform', installTask.group)
19 |         assertEquals(['--install', project.buildDir.absolutePath + File.separator + "javacard" + File.separator + "applet.cap",
20 |                       '--key-enc', '414142434445464748494A4B4C4D4E4F',
21 |                       '--key-mac', '404142434445464748494A4B4C4D4E4F',
22 |                       '--key-dek', '424142434445464748494A4B4C4D4E4F'
23 |         ], installTask.args)
24 |         assertEquals(installTask.main, 'pro.javacard.gp.GPTool')
25 |         //installTask.exec()
26 |     }
27 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/JavaCardInstallTaskTest.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard
 2 | 
 3 | import com.klinec.gradle.javacard.common.CommonTest
 4 | import org.gradle.api.Task
 5 | import org.gradle.api.tasks.JavaExec
 6 | import org.junit.Test
 7 | 
 8 | import static org.junit.Assert.assertEquals
 9 | import static org.junit.Assert.assertTrue
10 | import static org.junit.Assert.assertThat
11 | import static org.hamcrest.Matchers.*
12 | 
13 | class JavaCardInstallTaskTest extends CommonTest {
14 | 
15 |     @Test
16 |     void validBuildInstall() {
17 |         runBuildTask(StaticConfig.VALID_CONFIG)
18 |         JavaExec installTask = project.getTasks().getByName("installJavaCard")
19 |         Task buildTask = project.getTasks().getByName("buildJavaCard")
20 |         assertTrue(installTask ? true : false)
21 |         assertTrue(installTask instanceof JavaExec)
22 |         assertThat(installTask.dependsOn, hasItem(buildTask))
23 |         assertEquals(installTask.group, 'global platform')
24 |         assertEquals(installTask.args, ['--install', project.buildDir.absolutePath + File.separator + "javacard" + File.separator + "applet.cap",
25 |                                         '--key-enc', '404142434445464748494A4B4C4D4E4F',
26 |                                         '--key-mac', '404142434445464748494A4B4C4D4E4F',
27 |                                         '--key-dek', '404142434445464748494A4B4C4D4E4F'
28 |         ])
29 |         assertEquals(installTask.main, 'pro.javacard.gp.GPTool')
30 |         //installTask.exec()
31 |     }
32 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/gp/GpExec.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * The MIT License (MIT)
 3 |  * <p/>
 4 |  * Copyright (c) 2017-2018 Bertrand Martel
 5 |  * <p/>
 6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 7 |  * of this software and associated documentation files (the "Software"), to deal
 8 |  * in the Software without restriction, including without limitation the rights
 9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 |  * copies of the Software, and to permit persons to whom the Software is
11 |  * furnished to do so, subject to the following conditions:
12 |  * <p/>
13 |  * The above copyright notice and this permission notice shall be included in
14 |  * all copies or substantial portions of the Software.
15 |  * <p/>
16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 |  * THE SOFTWARE.
23 |  */
24 | 
25 | package com.klinec.gradle.javacard.gp
26 | 
27 | import org.gradle.api.tasks.JavaExec
28 | /**
29 |  * Task type that inherits JavaExec.
30 |  *
31 |  * @author Bertrand Martel
32 |  */
33 | class GpExec extends JavaExec {
34 | 
35 |     static String GP_CLASSNAME = 'pro.javacard.gp.GPTool'
36 | 
37 |     GpExec() {
38 |         super()
39 |         configure {
40 |             main = GP_CLASSNAME
41 |             classpath = project.configurations.gptool
42 |         }
43 |     }
44 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Script.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * The MIT License (MIT)
 3 |  * <p/>
 4 |  * Copyright (c) 2017 Bertrand Martel
 5 |  * <p/>
 6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 7 |  * of this software and associated documentation files (the "Software"), to deal
 8 |  * in the Software without restriction, including without limitation the rights
 9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 |  * copies of the Software, and to permit persons to whom the Software is
11 |  * furnished to do so, subject to the following conditions:
12 |  * <p/>
13 |  * The above copyright notice and this permission notice shall be included in
14 |  * all copies or substantial portions of the Software.
15 |  * <p/>
16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 |  * THE SOFTWARE.
23 |  */
24 | 
25 | package com.klinec.gradle.javacard.extension
26 | 
27 | /**
28 |  * a single script reference to send an apdu.
29 |  *
30 |  * @author Bertrand Martel
31 |  */
32 | class Script {
33 | 
34 |     /**
35 |      * script name.
36 |      */
37 |     String name
38 | 
39 |     /**
40 |      * apdu to send.
41 |      */
42 |     String apdu
43 | 
44 |     void name(String name) {
45 |         this.name = name
46 |     }
47 | 
48 |     void apdu(String apdu) {
49 |         this.apdu = apdu
50 |     }
51 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Task.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * The MIT License (MIT)
 3 |  * <p/>
 4 |  * Copyright (c) 2017 Bertrand Martel
 5 |  * <p/>
 6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 7 |  * of this software and associated documentation files (the "Software"), to deal
 8 |  * in the Software without restriction, including without limitation the rights
 9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 |  * copies of the Software, and to permit persons to whom the Software is
11 |  * furnished to do so, subject to the following conditions:
12 |  * <p/>
13 |  * The above copyright notice and this permission notice shall be included in
14 |  * all copies or substantial portions of the Software.
15 |  * <p/>
16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 |  * THE SOFTWARE.
23 |  */
24 | 
25 | package com.klinec.gradle.javacard.extension
26 | 
27 | /**
28 |  * define the created gradle task that will hold the scripts
29 |  *
30 |  * @author Bertrand Martel
31 |  */
32 | class Task {
33 | 
34 |     /**
35 |      * task name.
36 |      */
37 |     String name
38 | 
39 |     /**
40 |      * list of tasks.
41 |      */
42 |     List<String> scripts = []
43 | 
44 |     void name(String name) {
45 |         this.name = name
46 |     }
47 | 
48 |     void scripts(String... list) {
49 |         for (String item : list) {
50 |             this.scripts.add(item)
51 |         }
52 |     }
53 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/utils/TestUtils.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard.utils
 2 | 
 3 | import com.klinec.gradle.javacard.util.Utility
 4 | 
 5 | class TestUtils {
 6 | 
 7 |     public static File getFile(ext) {
 8 |         return new File(ext)
 9 |     }
10 | 
11 |     public static String getFileName(filePath, ext) {
12 |         return Utility.removeExtension(filePath) + "." + ext
13 |     }
14 | 
15 |     public static boolean isInt(String v){
16 |         try {
17 |             Integer.parseInt(v)
18 |             return true
19 |         } catch (Exception ignored){
20 |             return false
21 |         }
22 |     }
23 | 
24 |     public static int compareVersionElem(String v1, String v2){
25 |         if (isInt(v1) && isInt(v2)){
26 |             return Integer.parseInt(v1) - Integer.parseInt(v2)
27 |         } else {
28 |             return v1.numberAwareCompareTo(v2)
29 |         }
30 |     }
31 | 
32 |     public static int compareJdk(String version1, String version2) {
33 |         def arr1 = version1.split("\\.") as String[]
34 |         def arr2 = version2.split("\\.") as String[]
35 |         if (arr1[0] == '1') arr1 = arr1[(1..-1)]
36 |         if (arr2[0] == '1') arr2 = arr2[(1..-1)]
37 |         int i=0
38 | 
39 |         while(i<arr1.size() || i<arr2.size()){
40 |             if(i<arr1.size() && i<arr2.size()){
41 |                 def x = compareVersionElem(arr1[i], arr2[i])
42 |                 if (x != 0) {
43 |                     return x
44 |                 }
45 |             } else if(i<arr1.size()){
46 |                 if (compareVersionElem(arr1[i], "0") != 0){
47 |                     return 1
48 |                 }
49 |             } else if(i<arr2.size()){
50 |                 if (compareVersionElem(arr2[i], "0") != 0){
51 |                     return -1
52 |                 }
53 |             }
54 | 
55 |             i++;
56 |         }
57 |         return 0
58 |     }
59 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/UtilityTest.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * The MIT License (MIT)
 3 |  * <p/>
 4 |  * Copyright (c) 2017 Bertrand Martel
 5 |  * <p/>
 6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 7 |  * of this software and associated documentation files (the "Software"), to deal
 8 |  * in the Software without restriction, including without limitation the rights
 9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 |  * copies of the Software, and to permit persons to whom the Software is
11 |  * furnished to do so, subject to the following conditions:
12 |  * <p/>
13 |  * The above copyright notice and this permission notice shall be included in
14 |  * all copies or substantial portions of the Software.
15 |  * <p/>
16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 |  * THE SOFTWARE.
23 |  */
24 | 
25 | package com.klinec.gradle.javacard
26 | 
27 | import com.klinec.gradle.javacard.util.Utility
28 | import org.junit.Test
29 | 
30 | import static org.junit.Assert.assertEquals
31 | 
32 | /**
33 |  * Test utility functions.
34 |  *
35 |  * @author Bertrand Martel
36 |  */
37 | class UtilityTest {
38 | 
39 |     @Test
40 |     void removeExtensionTest() {
41 |         assertEquals("test", Utility.removeExtension("test.txt"))
42 |         assertEquals("/some/path/file", Utility.removeExtension("/some/path/file.cap"))
43 |         assertEquals("test_test", Utility.removeExtension("test_test.exp"))
44 |         assertEquals("somefile.txt", Utility.removeExtension("somefile.txt.txt"))
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Import.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * The MIT License (MIT)
 3 |  * <p/>
 4 |  * Copyright (c) 2017 Bertrand Martel
 5 |  * <p/>
 6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 7 |  * of this software and associated documentation files (the "Software"), to deal
 8 |  * in the Software without restriction, including without limitation the rights
 9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 |  * copies of the Software, and to permit persons to whom the Software is
11 |  * furnished to do so, subject to the following conditions:
12 |  * <p/>
13 |  * The above copyright notice and this permission notice shall be included in
14 |  * all copies or substantial portions of the Software.
15 |  * <p/>
16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 |  * THE SOFTWARE.
23 |  */
24 | 
25 | package com.klinec.gradle.javacard.extension
26 | 
27 | /**
28 |  * Cap extension object (the same as defined in https://github.com/martinpaljak/ant-javacard#syntax
29 |  *
30 |  * @author Bertrand Martel
31 |  */
32 | class Import {
33 | 
34 |     /**
35 |      * path to the folder keeping .exp files. Required
36 |      */
37 |     String exps
38 | 
39 |     /**
40 |      * path to the JAR file for compilation. Optional - only required if using sources mode and not necessary with classes mode if java code is already compiled
41 |      */
42 |     String jar
43 | 
44 |     void exps(String exps) {
45 |         this.exps = exps
46 |     }
47 | 
48 |     void jar(String jar) {
49 |         this.jar = jar
50 |     }
51 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Applet.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * The MIT License (MIT)
 3 |  * <p/>
 4 |  * Copyright (c) 2017 Bertrand Martel
 5 |  * <p/>
 6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 7 |  * of this software and associated documentation files (the "Software"), to deal
 8 |  * in the Software without restriction, including without limitation the rights
 9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 |  * copies of the Software, and to permit persons to whom the Software is
11 |  * furnished to do so, subject to the following conditions:
12 |  * <p/>
13 |  * The above copyright notice and this permission notice shall be included in
14 |  * all copies or substantial portions of the Software.
15 |  * <p/>
16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 |  * THE SOFTWARE.
23 |  */
24 | 
25 | package com.klinec.gradle.javacard.extension
26 | 
27 | /**
28 |  * Cap extension object (the same as defined in https://github.com/martinpaljak/ant-javacard#syntax
29 |  *
30 |  * @author Bertrand Martel
31 |  */
32 | class Applet {
33 | 
34 |     /**
35 |      * class of the Applet where install() method is defined. Required.
36 |      */
37 |     String className
38 | 
39 |     /**
40 |      * AID (hex) of the applet. Recommended - or set to package aid+i where i is index of the applet definition in the build.xml instruction
41 |      */
42 |     String aid
43 | 
44 |     void className(String className) {
45 |         this.className = className
46 |     }
47 | 
48 |     void aid(String aid) {
49 |         this.aid = aid
50 |     }
51 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/util/SdkUtils.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard.util
 2 | 
 3 | import org.slf4j.Logger
 4 | 
 5 | import java.nio.file.Paths
 6 | 
 7 | import pro.javacard.JavaCardSDK
 8 | 
 9 | /**
10 |  * Javacard SDK utils taken from ant-javacard(https://github.com/martinpaljak/ant-javacard) by Martin Paljak
11 |  */
12 | class SdkUtils {
13 | 
14 |     static class JavaCardKit {
15 |         JavaCardSDK.Version version = JavaCardSDK.Version.NONE
16 |         String path = null
17 |         JavaCardSDK sdk = null
18 |     }
19 | 
20 |     /**
21 |      * Get api classpath depending on SDK version
22 |      *
23 |      * @param extensionKit path to JavaCard SDK
24 |      * @return api jar classpath
25 |      */
26 |     static getApiPath(extensionKit, Logger logger) {
27 |         def jckit = SdkUtils.detectSDK(extensionKit, logger)
28 |         def jars = jckit.sdk.getApiJars()
29 |         return jars.isEmpty() ? null : jars.get(0)
30 |     }
31 | 
32 |     /**
33 |      * Given a path, return a meta-info object about possible JavaCard SDK in that path.
34 |      *
35 |      * @param path raw string as present in build.xml or environment, or <code>null</code>
36 |      *
37 |      * @return a {@link JavaCardKit} instance
38 |      */
39 |     static JavaCardKit detectSDK(String path, Logger logger) {
40 |         JavaCardKit detected = new JavaCardKit()
41 |         if (path == null || path.trim() == "") {
42 |             return detected
43 |         }
44 | 
45 |         // Expand user
46 |         String real_path = path.replaceFirst("^~", System.getProperty("user.home"))
47 | 
48 |         // Check if path is OK
49 |         if (!new File(real_path).exists()) {
50 |             logger.info("JavaCard SDK folder " + path + " does not exist!")
51 |             return detected
52 |         }
53 | 
54 |         detected.sdk = JavaCardSDK.detectSDK(real_path)
55 |         detected.version = detected.sdk?.version
56 |         detected.path = real_path
57 | 
58 |         // Identify jckit type
59 |         if (!detected.sdk) {
60 |             logger.info("Could not detect a JavaCard SDK in " + Paths.get(path).toAbsolutePath())
61 |         }
62 |         return detected
63 |     }
64 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Key.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * The MIT License (MIT)
 3 |  * <p/>
 4 |  * Copyright (c) 2017 Bertrand Martel
 5 |  * <p/>
 6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 7 |  * of this software and associated documentation files (the "Software"), to deal
 8 |  * in the Software without restriction, including without limitation the rights
 9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 |  * copies of the Software, and to permit persons to whom the Software is
11 |  * furnished to do so, subject to the following conditions:
12 |  * <p/>
13 |  * The above copyright notice and this permission notice shall be included in
14 |  * all copies or substantial portions of the Software.
15 |  * <p/>
16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 |  * THE SOFTWARE.
23 |  */
24 | 
25 | package com.klinec.gradle.javacard.extension
26 | 
27 | /**
28 |  * Key extension.
29 |  *
30 |  * @author Bertrand Martel
31 |  */
32 | class Key {
33 | 
34 |     /**
35 |      * key Master
36 |      */
37 |     String keyMaster
38 | 
39 |     /**
40 |      * key DEK
41 |      */
42 |     String keyDek
43 | 
44 |     /**
45 |      * key ENC
46 |      */
47 |     String keyEnc
48 | 
49 |     /**
50 |      * key MAC
51 |      */
52 |     String keyMac
53 | 
54 |     /**
55 |      * key KEK
56 |      */
57 |     String keyKek
58 | 
59 |     void enc(String key) {
60 |         this.keyEnc = key
61 |     }
62 | 
63 |     void mac(String key) {
64 |         this.keyMac = key
65 |     }
66 | 
67 |     void kek(String key) {
68 |         this.keyKek = key
69 |     }
70 | 
71 |     void master(String key){
72 |         this.keyMaster = key
73 |     }
74 | 
75 |     void dek(String key){
76 |         this.keyDek = key
77 |     }
78 | 
79 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/JavaCardScriptTest.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard
 2 | 
 3 | import com.klinec.gradle.javacard.common.CommonTest
 4 | import org.gradle.api.Task
 5 | import org.gradle.api.tasks.JavaExec
 6 | import org.junit.Test
 7 | 
 8 | import static org.junit.Assert.assertEquals
 9 | import static org.junit.Assert.assertTrue
10 | 
11 | class JavaCardScriptTest extends CommonTest {
12 | 
13 |     @Test
14 |     void validScript() {
15 |         runBuildTask(StaticConfig.VALID_SCRIPT_CONFIG)
16 | 
17 |         Task task1 = project.getTasks().findByName('task1')
18 |         Task task2 = project.getTasks().findByName('task2')
19 |         Task task3 = project.getTasks().findByName('task3')
20 | 
21 |         assertTrue(task1 ? true : false)
22 |         assertTrue(task2 ? true : false)
23 |         assertTrue(task3 ? true : false)
24 | 
25 |         assertTrue(task1 instanceof JavaExec)
26 |         assertTrue(task2 instanceof JavaExec)
27 |         assertTrue(task3 instanceof JavaExec)
28 | 
29 |         assertEquals(task1.group, 'global platform')
30 |         assertEquals(task2.group, 'global platform')
31 |         assertEquals(task3.group, 'global platform')
32 | 
33 |         assertEquals(task1.args, ['-a', '010203', '-a', '040506'])
34 |         assertEquals(task2.args, ['-a', '010203'])
35 |         assertEquals(task3.args, ['-a', '040506'])
36 | 
37 |         assertEquals(task1.main, 'pro.javacard.gp.GPTool')
38 |         assertEquals(task2.main, 'pro.javacard.gp.GPTool')
39 |         assertEquals(task3.main, 'pro.javacard.gp.GPTool')
40 | 
41 |         //task1.exec()
42 |     }
43 | 
44 |     @Test
45 |     void runnableScript() {
46 |         runBuildTask(StaticConfig.RUNNABLE_SCRIPT_CONFIG)
47 | 
48 |         JavaExec installTask = project.getTasks().getByName("installJavaCard")
49 |         JavaExec task1 = project.getTasks().getByName('task1')
50 | 
51 |         assertTrue(task1 ? true : false)
52 |         assertTrue(task1 instanceof JavaExec)
53 |         assertEquals(task1.group, 'global platform')
54 |         assertEquals(task1.args, ['-a', '00A404000A0102030405060708090100', '-a', '0040000000'])
55 |         assertEquals(task1.main, 'pro.javacard.gp.GPTool')
56 | 
57 |         //installTask.exec()
58 |         //task1.exec()
59 |     }
60 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Dependencies.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * The MIT License (MIT)
 3 |  * <p/>
 4 |  * Copyright (c) 2017 Bertrand Martel
 5 |  * <p/>
 6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 7 |  * of this software and associated documentation files (the "Software"), to deal
 8 |  * in the Software without restriction, including without limitation the rights
 9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 |  * copies of the Software, and to permit persons to whom the Software is
11 |  * furnished to do so, subject to the following conditions:
12 |  * <p/>
13 |  * The above copyright notice and this permission notice shall be included in
14 |  * all copies or substantial portions of the Software.
15 |  * <p/>
16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 |  * THE SOFTWARE.
23 |  */
24 | 
25 | package com.klinec.gradle.javacard.extension
26 | 
27 | import org.gradle.api.Action
28 | import org.gradle.api.model.ObjectFactory
29 | import org.gradle.util.ClosureBackedAction
30 | 
31 | import javax.inject.Inject
32 | 
33 | /**
34 |  * Cap extension object (the same as defined in https://github.com/martinpaljak/ant-javacard#syntax
35 |  *
36 |  * @author Bertrand Martel
37 |  */
38 | abstract class Dependencies {
39 | 
40 |     /**
41 |      * list of local exp/jar dependencies
42 |      */
43 |     List<Import> local = []
44 | 
45 |     /**
46 |      * list of remote exp/jar dependencies
47 |      */
48 |     List<String> remote = []
49 | 
50 |     void remote(String remote) {
51 |         this.remote.add(remote)
52 |     }
53 | 
54 |     Import local(Closure closure) {
55 |         local(ClosureBackedAction.of(closure))
56 |     }
57 | 
58 |     Import local(Action<Import> action) {
59 |         def someLocal = objectFactory.newInstance(Import)
60 |         action.execute(someLocal)
61 |         local.add(someLocal)
62 |         return someLocal
63 |     }
64 | 
65 |     @Inject
66 |     abstract ObjectFactory getObjectFactory()
67 | }


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Change Log
 2 | 
 3 | ## [1.5.4](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.5.4) (2018-03-03)
 4 | [Full Changelog](https://github.com/bertrandmartel/javacard-gradle-plugin/compare/1.5.3...1.5.4)
 5 | 
 6 | **Merged pull requests:**
 7 | 
 8 | - finding sources automatically by default - from the existing source sets [\#3](https://github.com/bertrandmartel/javacard-gradle-plugin/pull/3) ([ph4r05](https://github.com/ph4r05))
 9 | - More flexible JcardSim configuration [\#2](https://github.com/bertrandmartel/javacard-gradle-plugin/pull/2) ([ph4r05](https://github.com/ph4r05))
10 | 
11 | ## [1.5.3](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.5.3) (2017-10-10)
12 | [Full Changelog](https://github.com/bertrandmartel/javacard-gradle-plugin/compare/1.5.2...1.5.3)
13 | 
14 | **Closed issues:**
15 | 
16 | - Depend on another module [\#1](https://github.com/bertrandmartel/javacard-gradle-plugin/issues/1)
17 | 
18 | ## [1.5.2](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.5.2) (2017-09-23)
19 | [Full Changelog](https://github.com/bertrandmartel/javacard-gradle-plugin/compare/1.5.0...1.5.2)
20 | 
21 | ## [1.5.0](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.5.0) (2017-09-02)
22 | [Full Changelog](https://github.com/bertrandmartel/javacard-gradle-plugin/compare/1.4.1...1.5.0)
23 | 
24 | ## [1.4.1](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.4.1) (2017-08-31)
25 | [Full Changelog](https://github.com/bertrandmartel/javacard-gradle-plugin/compare/1.4.0...1.4.1)
26 | 
27 | ## [1.4.0](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.4.0) (2017-08-30)
28 | [Full Changelog](https://github.com/bertrandmartel/javacard-gradle-plugin/compare/1.3.0...1.4.0)
29 | 
30 | ## [1.3.0](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.3.0) (2017-08-21)
31 | [Full Changelog](https://github.com/bertrandmartel/javacard-gradle-plugin/compare/1.2.3...1.3.0)
32 | 
33 | ## [1.2.3](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.2.3) (2017-08-19)
34 | [Full Changelog](https://github.com/bertrandmartel/javacard-gradle-plugin/compare/1.2.0...1.2.3)
35 | 
36 | ## [1.2.0](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.2.0) (2017-08-18)
37 | [Full Changelog](https://github.com/bertrandmartel/javacard-gradle-plugin/compare/1.1.1...1.2.0)
38 | 
39 | ## [1.1.1](https://github.com/bertrandmartel/javacard-gradle-plugin/tree/1.1.1) (2017-08-13)
40 | 
41 | 
42 | \* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Scripts.groovy:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * The MIT License (MIT)
 3 |  * <p/>
 4 |  * Copyright (c) 2017 Bertrand Martel
 5 |  * <p/>
 6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
 7 |  * of this software and associated documentation files (the "Software"), to deal
 8 |  * in the Software without restriction, including without limitation the rights
 9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 |  * copies of the Software, and to permit persons to whom the Software is
11 |  * furnished to do so, subject to the following conditions:
12 |  * <p/>
13 |  * The above copyright notice and this permission notice shall be included in
14 |  * all copies or substantial portions of the Software.
15 |  * <p/>
16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 |  * THE SOFTWARE.
23 |  */
24 | 
25 | package com.klinec.gradle.javacard.extension
26 | 
27 | import org.gradle.api.Action
28 | import org.gradle.api.model.ObjectFactory
29 | import org.gradle.util.ClosureBackedAction
30 | 
31 | import javax.inject.Inject
32 | 
33 | /**
34 |  * scripts used to configure apdu batch request from a gradle task.
35 |  *
36 |  * @author Bertrand Martel
37 |  */
38 | abstract class Scripts {
39 | 
40 |     /**
41 |      * list of scripts.
42 |      */
43 |     List<Script> scripts = []
44 | 
45 |     /**
46 |      * list of tasks.
47 |      */
48 |     List<Task> tasks = []
49 | 
50 |     Script script(Closure closure) {
51 |         script(ClosureBackedAction.of(closure))
52 |     }
53 | 
54 |     Script script(Action<Script> action) {
55 |         def scriptInst = objectFactory.newInstance(Script)
56 |         action.execute(scriptInst)
57 |         scripts.add(scriptInst)
58 |         scriptInst
59 |     }
60 | 
61 |     Task task(Closure closure) {
62 |         task(ClosureBackedAction.of(closure))
63 |     }
64 | 
65 |     Task task(Action<Task> action) {
66 |         def taskInt = objectFactory.newInstance(Task)
67 |         action.execute(taskInt)
68 |         tasks.add(taskInt)
69 |         taskInt
70 |     }
71 | 
72 |     @Inject
73 |     abstract ObjectFactory getObjectFactory()
74 | }


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @if "%DEBUG%" == "" @echo off
 2 | @rem ##########################################################################
 3 | @rem
 4 | @rem  Gradle startup script for Windows
 5 | @rem
 6 | @rem ##########################################################################
 7 | 
 8 | @rem Set local scope for the variables with windows NT shell
 9 | if "%OS%"=="Windows_NT" setlocal
10 | 
11 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
12 | set DEFAULT_JVM_OPTS=
13 | 
14 | set DIRNAME=%~dp0
15 | if "%DIRNAME%" == "" set DIRNAME=.
16 | set APP_BASE_NAME=%~n0
17 | set APP_HOME=%DIRNAME%
18 | 
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 | 
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 | 
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 | 
32 | goto fail
33 | 
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 | 
38 | if exist "%JAVA_EXE%" goto init
39 | 
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 | 
46 | goto fail
47 | 
48 | :init
49 | @rem Get command-line arguments, handling Windowz variants
50 | 
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 | if "%@eval[2+2]" == "4" goto 4NT_args
53 | 
54 | :win9xME_args
55 | @rem Slurp the command line arguments.
56 | set CMD_LINE_ARGS=
57 | set _SKIP=2
58 | 
59 | :win9xME_args_slurp
60 | if "x%~1" == "x" goto execute
61 | 
62 | set CMD_LINE_ARGS=%*
63 | goto execute
64 | 
65 | :4NT_args
66 | @rem Get arguments from the 4NT Shell from JP Software
67 | set CMD_LINE_ARGS=%$
68 | 
69 | :execute
70 | @rem Setup the command line
71 | 
72 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
73 | 
74 | @rem Execute Gradle
75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
76 | 
77 | :end
78 | @rem End local scope for the variables with windows NT shell
79 | if "%ERRORLEVEL%"=="0" goto mainEnd
80 | 
81 | :fail
82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
83 | rem the _cmd.exe /c_ return code!
84 | if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
85 | exit /b 1
86 | 
87 | :mainEnd
88 | if "%OS%"=="Windows_NT" endlocal
89 | 
90 | :omega
91 | 


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/common/CommonTest.groovy:
--------------------------------------------------------------------------------
 1 | package com.klinec.gradle.javacard.common
 2 | 
 3 | 
 4 | import com.klinec.gradle.javacard.utils.TestUtils;
 5 | import groovy.lang.Closure;
 6 | import org.gradle.api.Project;
 7 | import org.gradle.testfixtures.ProjectBuilder;
 8 | import org.junit.Before
 9 | 
10 | import static org.junit.Assert.assertTrue;
11 | 
12 | public class CommonTest {
13 | 
14 |     protected static Project project
15 |     protected static com.klinec.gradle.javacard.JavaCardBuildTask task
16 | 
17 |     protected static String buildDir = System.getProperty("user.dir") + "/build"
18 |     protected static String buildJavaCardDir = buildDir + "/javacard"
19 | 
20 |     @Before
21 |     void setUpProject() {
22 |         project = ProjectBuilder.builder().build()
23 |         project.apply plugin: 'javacard'
24 | 
25 |         //set build directory
26 |         project.setBuildDir(buildDir)
27 | 
28 |         //set source path
29 |         project.sourceSets {
30 |             main {
31 |                 java {
32 |                     srcDirs = [System.getProperty("user.dir") + "/../test/src/main/java"]
33 |                 }
34 |             }
35 |         }
36 |         task = project.getTasks().getByName("buildJavaCard")
37 |     }
38 | 
39 |     void configureProject(Closure closure) {
40 |         project.configure(project.javacard, closure)
41 |     }
42 | 
43 |     void runBuildTask(Closure closure) {
44 |         deleteBuildDir()
45 |         configureProject(closure)
46 |         def buildRepo = project.repositories.maven {
47 |             name 'build'
48 |             url "http://dl.bintray.com/bertrandmartel/maven"
49 |         }
50 |         project.repositories.add(buildRepo)
51 |         project.repositories.add(project.repositories.mavenCentral())
52 |         project.evaluate()
53 |         task.build()
54 |         checkOutputFile(task)
55 |     }
56 | 
57 |     void checkOutputFile(task) {
58 |         task.getJavaCard().config.caps.each {
59 |             capItem ->
60 |                 assertTrue(TestUtils.getFile(capItem.output).exists())
61 |                 if (capItem.export?.trim()) {
62 |                     assertTrue(TestUtils.getFile(TestUtils.getFileName(capItem.export, "exp")).exists())
63 |                 } else {
64 |                     assertTrue(TestUtils.getFile(TestUtils.getFileName(capItem.output, "exp")).exists())
65 |                 }
66 |                 if (capItem.jca?.trim()) {
67 |                     assertTrue(TestUtils.getFile(TestUtils.getFileName(capItem.jca, "jca")).exists())
68 |                 } else {
69 |                     assertTrue(TestUtils.getFile(TestUtils.getFileName(capItem.output, "jca")).exists())
70 |                 }
71 |         }
72 |     }
73 | 
74 |     void deleteBuildDir() {
75 |         File dir = new File(buildJavaCardDir)
76 |         dir.deleteDir()
77 |     }
78 | }
79 | 


--------------------------------------------------------------------------------
/gradle/old.gradle:
--------------------------------------------------------------------------------
 1 | //bintray {
 2 | //    user = "$System.env.BINTRAY_USER"
 3 | //    key = "$System.env.BINTRAY_KEY"
 4 | //
 5 | //    configurations = ['archives'] //When uploading configuration files
 6 | //
 7 | //    dryRun = false //Whether to run this as dry-run, without deploying
 8 | //    publish = true //If version should be auto published after an upload
 9 | //
10 | //    pkg {
11 | //        repo = 'maven'
12 | //        name = 'gradle-javacard'
13 | //        desc = 'JavaCard gradle plugin'
14 | //        websiteUrl = siteUrl
15 | //        issueTrackerUrl = 'https://github.com/ph4r05/javacard-gradle-plugin/issues'
16 | //        vcsUrl = gitUrl
17 | //        licenses = ['MIT']
18 | //        labels = ['javacard', 'gradle-plugin']
19 | //        publicDownloadNumbers = true
20 | //
21 | //        version {
22 | //            name = project.version //Bintray logical version name
23 | //            vcsTag = project.version
24 | //
25 | //            gpg {
26 | //                sign = true
27 | //                passphrase = "$System.env.GPG_PASSPHRASE"
28 | //            }
29 | //
30 | //            mavenCentralSync {
31 | //                sync = true
32 | //                //Optional (true by default). Determines whether to sync the version to Maven Central.
33 | //                user = "$System.env.MAVEN_CENTRAL_USER_TOKEN" //OSS user token
34 | //                password = "$System.env.MAVEN_CENTRAL_PASSWORD" //OSS user password
35 | //                close = '1'
36 | //                //Optional property. By default the staging repository is closed and artifacts are released to Maven Central. You can optionally turn this behaviour off (by puting 0 as value) and release the version manually.
37 | //            }
38 | //        }
39 | //    }
40 | //}
41 | //
42 | //install {
43 | //    repositories.mavenInstaller {
44 | //        pom {
45 | //            project {
46 | //                description 'JavaCard gradle plugin'
47 | //                packaging 'jar'
48 | //                name 'gradle-javacard'
49 | //                url siteUrl
50 | //                licenses {
51 | //                    license {
52 | //                        name 'The MIT License'
53 | //                        url 'https://github.com/ph4r05/javacard-gradle-plugin/blob/master/LICENSE.md'
54 | //                    }
55 | //                }
56 | //                developers {
57 | //                    developer {
58 | //                        id 'bertrandmartel'
59 | //                        name 'Bertrand Martel'
60 | //                        email 'bmartel.fr@gmail.com'
61 | //                    }
62 | //                    developer {
63 | //                        id 'ph4r05'
64 | //                        name 'Dusan Klinec'
65 | //                        email 'dusan.klinec@gmail.com'
66 | //                    }
67 | //                }
68 | //                scm {
69 | //                    connection 'https://github.com/ph4r05/javacard-gradle-plugin.git'
70 | //                    developerConnection 'https://github.com/ph4r05/javacard-gradle-plugin.git'
71 | //                    url siteUrl
72 | //                }
73 | //            }
74 | //            whenConfigured {
75 | //                p ->
76 | //                    p.dependencies = p.dependencies.findAll {
77 | //                        dep -> (dep.artifactId.notIn(["junit", "hamcrest-all"]))
78 | //                    }
79 | //            }
80 | //        }
81 | //    }
82 | //}


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/JavaCard.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The MIT License (MIT)
  3 |  * <p/>
  4 |  * Copyright (c) 2017 Bertrand Martel
  5 |  * <p/>
  6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7 |  * of this software and associated documentation files (the "Software"), to deal
  8 |  * in the Software without restriction, including without limitation the rights
  9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 |  * copies of the Software, and to permit persons to whom the Software is
 11 |  * furnished to do so, subject to the following conditions:
 12 |  * <p/>
 13 |  * The above copyright notice and this permission notice shall be included in
 14 |  * all copies or substantial portions of the Software.
 15 |  * <p/>
 16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 |  * THE SOFTWARE.
 23 |  */
 24 | 
 25 | package com.klinec.gradle.javacard.extension
 26 | 
 27 | import org.gradle.api.Action
 28 | import org.gradle.api.Project
 29 | import org.gradle.api.model.ObjectFactory
 30 | import org.gradle.util.ClosureBackedAction
 31 | 
 32 | import javax.inject.Inject
 33 | 
 34 | /**
 35 |  * JavaCard extension object (the same as defined in https://github.com/martinpaljak/ant-javacard#syntax
 36 |  *
 37 |  * @author Bertrand Martel
 38 |  */
 39 | abstract class JavaCard {
 40 | 
 41 |     Config config
 42 | 
 43 |     Scripts scripts
 44 | 
 45 |     Key key
 46 | 
 47 |     String defaultKey
 48 | 
 49 |     Test test
 50 | 
 51 |     Config config(Closure closure) {
 52 |         config(ClosureBackedAction.of(closure))
 53 |     }
 54 | 
 55 |     Config config(Action<Config> action) {
 56 |         def someConfig = objectFactory.newInstance(Config)
 57 |         action.execute(someConfig)
 58 |         config = someConfig
 59 |         return someConfig
 60 |     }
 61 | 
 62 |     Scripts scripts(Closure closure) {
 63 |         scripts(ClosureBackedAction.of(closure))
 64 |     }
 65 | 
 66 |     Scripts scripts(Action<Scripts> action) {
 67 |         def someScript = objectFactory.newInstance(Scripts)
 68 |         action.execute(someScript)
 69 |         scripts = someScript
 70 |         return someScript
 71 |     }
 72 | 
 73 |     Test test(Closure closure) {
 74 |         test(ClosureBackedAction.of(closure))
 75 |     }
 76 | 
 77 |     Test test(Action<Test> action) {
 78 |         def someTest = objectFactory.newInstance(Test)
 79 |         action.execute(someTest)
 80 |         test = someTest
 81 |         return someTest
 82 |     }
 83 | 
 84 |     Key key(Closure closure) {
 85 |         key(ClosureBackedAction.of(closure))
 86 |     }
 87 | 
 88 |     Key key(Action<Key> action) {
 89 |         def someKey = objectFactory.newInstance(Key)
 90 |         action.execute(someKey)
 91 |         key = someKey
 92 |         return someKey
 93 |     }
 94 | 
 95 |     void defaultKey(String key) {
 96 |         this.defaultKey = key
 97 |     }
 98 | 
 99 |     /**
100 |      * Validate fields
101 |      */
102 |     def validate(Project project) {
103 |         config.validate(project)
104 |     }
105 | 
106 |     @Inject
107 |     abstract ObjectFactory getObjectFactory()
108 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/util/Utility.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The MIT License (MIT)
  3 |  * <p/>
  4 |  * Copyright (c) 2017 Bertrand Martel
  5 |  * <p/>
  6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7 |  * of this software and associated documentation files (the "Software"), to deal
  8 |  * in the Software without restriction, including without limitation the rights
  9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 |  * copies of the Software, and to permit persons to whom the Software is
 11 |  * furnished to do so, subject to the following conditions:
 12 |  * <p/>
 13 |  * The above copyright notice and this permission notice shall be included in
 14 |  * all copies or substantial portions of the Software.
 15 |  * <p/>
 16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 |  * THE SOFTWARE.
 23 |  */
 24 | 
 25 | package com.klinec.gradle.javacard.util
 26 | 
 27 | import java.util.zip.ZipFile
 28 | 
 29 | /**
 30 |  * Some utility functions
 31 |  *
 32 |  * @author Bertrand Martel
 33 |  */
 34 | class Utility {
 35 | 
 36 |     /**
 37 |      * Remove extension from file path but keep the path
 38 |      * https://stackoverflow.com/a/34321971/2614364
 39 |      *
 40 |      * @param file path
 41 |      * @return
 42 |      */
 43 |     static String removeExtension(file) {
 44 |         return file[0..<file.lastIndexOf('.')]
 45 |     }
 46 | 
 47 |     /**
 48 |      * Create a folder if not existing.
 49 |      *
 50 |      * @param folderPath
 51 |      */
 52 |     static void createFolder(folderPath) {
 53 |         def folder = new File(folderPath)
 54 |         if (!folder.exists()) {
 55 |             folder.mkdirs()
 56 |         }
 57 |     }
 58 | 
 59 |     /**
 60 |      * Unzip file to directory.
 61 |      *
 62 |      * @param zipFileName
 63 |      * @param outputDir
 64 |      */
 65 |     static void unzip(String zipFileName, String outputDir) {
 66 |         def zip = new ZipFile(new File(zipFileName))
 67 | 
 68 |         zip.entries().each {
 69 |             if (!it.isDirectory()) {
 70 |                 def fOut = new File(outputDir + File.separator + it.name)
 71 |                 new File(fOut.parent).mkdirs()
 72 |                 def fos = new FileOutputStream(fOut)
 73 |                 def buf = new byte[it.size]
 74 |                 def len = zip.getInputStream(it).read(buf)
 75 |                 fos.write(buf, 0, len)
 76 |                 fos.close()
 77 |             }
 78 |         }
 79 |         zip.close()
 80 |     }
 81 | 
 82 |     static String formatByteArray(apdu) {
 83 |         return apdu.replaceAll(':', '')
 84 |     }
 85 | 
 86 |     /**
 87 |      * Add keys to GPExec arguments.
 88 |      *
 89 |      * @param key
 90 |      * @param args
 91 |      * @return
 92 |      */
 93 |     static def addKeyArg(key, defaultKey, args) {
 94 |         if (key != null || defaultKey != null) {
 95 | 
 96 |             //set key-enc if specified otherwise set default key
 97 |             if (key != null && key.keyEnc != null) {
 98 |                 args.add('--key-enc')
 99 |                 args.add(Utility.formatByteArray(key.keyEnc))
100 |             } else if (defaultKey != null) {
101 |                 args.add('--key-enc')
102 |                 args.add(Utility.formatByteArray(defaultKey))
103 |             }
104 | 
105 |             //set key-mac if specified otherwise set default key
106 |             if (key != null && key.keyMac != null) {
107 |                 args.add('--key-mac')
108 |                 args.add(Utility.formatByteArray(key.keyMac))
109 |             } else if (defaultKey != null) {
110 |                 args.add('--key-mac')
111 |                 args.add(Utility.formatByteArray(defaultKey))
112 |             }
113 | 
114 |             //set key-kek if specified otherwise set default key
115 |             def kek = key == null ? null : (key.keyKek ?: key.keyDek ?: null)
116 |             if (kek != null) {
117 |                 args.add('--key-dek')
118 |                 args.add(Utility.formatByteArray(kek))
119 |             } else if (defaultKey != null) {
120 |                 args.add('--key-dek')
121 |                 args.add(Utility.formatByteArray(defaultKey))
122 |             }
123 | 
124 |             //set master key if specified otherwise set default key
125 |             if (key != null && key.keyMaster != null) {
126 |                 args.add('--key')
127 |                 args.add(Utility.formatByteArray(key.keyMaster))
128 |             }
129 |         }
130 |         return args
131 |     }
132 | 
133 |     /**
134 |      * Adds additional GpPro arguments as specified by configuration.
135 |      * Now supports only debugging flag.
136 |      *
137 |      * @param ext
138 |      * @param args
139 |      * @return
140 |      */
141 |     static def addGpProArgs(ext, args) {
142 |         if (ext.config.debugGpPro) {
143 |             args.add('-d')
144 |         }
145 |         return args
146 |     }
147 | 
148 |     /**
149 |      * Adds all arguments from srcArgs to the args
150 |      * @param srcArgs
151 |      * @param args
152 |      * @return
153 |      */
154 |     static def addAuxGpProArgs(srcArgs, args) {
155 |         if (srcArgs == null) return args
156 |         for (String item : srcArgs) {
157 |             args.add(item)
158 |         }
159 |         return args
160 |     }
161 | }


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env bash
  2 | 
  3 | ##############################################################################
  4 | ##
  5 | ##  Gradle start up script for UN*X
  6 | ##
  7 | ##############################################################################
  8 | 
  9 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 10 | DEFAULT_JVM_OPTS=""
 11 | 
 12 | APP_NAME="Gradle"
 13 | APP_BASE_NAME=`basename "$0"`
 14 | 
 15 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 16 | MAX_FD="maximum"
 17 | 
 18 | warn ( ) {
 19 |     echo "$*"
 20 | }
 21 | 
 22 | die ( ) {
 23 |     echo
 24 |     echo "$*"
 25 |     echo
 26 |     exit 1
 27 | }
 28 | 
 29 | # OS specific support (must be 'true' or 'false').
 30 | cygwin=false
 31 | msys=false
 32 | darwin=false
 33 | case "`uname`" in
 34 |   CYGWIN* )
 35 |     cygwin=true
 36 |     ;;
 37 |   Darwin* )
 38 |     darwin=true
 39 |     ;;
 40 |   MINGW* )
 41 |     msys=true
 42 |     ;;
 43 | esac
 44 | 
 45 | # For Cygwin, ensure paths are in UNIX format before anything is touched.
 46 | if $cygwin ; then
 47 |     [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
 48 | fi
 49 | 
 50 | # Attempt to set APP_HOME
 51 | # Resolve links: $0 may be a link
 52 | PRG="$0"
 53 | # Need this for relative symlinks.
 54 | while [ -h "$PRG" ] ; do
 55 |     ls=`ls -ld "$PRG"`
 56 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 57 |     if expr "$link" : '/.*' > /dev/null; then
 58 |         PRG="$link"
 59 |     else
 60 |         PRG=`dirname "$PRG"`"/$link"
 61 |     fi
 62 | done
 63 | SAVED="`pwd`"
 64 | cd "`dirname \"$PRG\"`/" >&-
 65 | APP_HOME="`pwd -P`"
 66 | cd "$SAVED" >&-
 67 | 
 68 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 69 | 
 70 | # Determine the Java command to use to start the JVM.
 71 | if [ -n "$JAVA_HOME" ] ; then
 72 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
 73 |         # IBM's JDK on AIX uses strange locations for the executables
 74 |         JAVACMD="$JAVA_HOME/jre/sh/java"
 75 |     else
 76 |         JAVACMD="$JAVA_HOME/bin/java"
 77 |     fi
 78 |     if [ ! -x "$JAVACMD" ] ; then
 79 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
 80 | 
 81 | Please set the JAVA_HOME variable in your environment to match the
 82 | location of your Java installation."
 83 |     fi
 84 | else
 85 |     JAVACMD="java"
 86 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 87 | 
 88 | Please set the JAVA_HOME variable in your environment to match the
 89 | location of your Java installation."
 90 | fi
 91 | 
 92 | # Increase the maximum file descriptors if we can.
 93 | if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
 94 |     MAX_FD_LIMIT=`ulimit -H -n`
 95 |     if [ $? -eq 0 ] ; then
 96 |         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
 97 |             MAX_FD="$MAX_FD_LIMIT"
 98 |         fi
 99 |         ulimit -n $MAX_FD
100 |         if [ $? -ne 0 ] ; then
101 |             warn "Could not set maximum file descriptor limit: $MAX_FD"
102 |         fi
103 |     else
104 |         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
105 |     fi
106 | fi
107 | 
108 | # For Darwin, add options to specify how the application appears in the dock
109 | if $darwin; then
110 |     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
111 | fi
112 | 
113 | # For Cygwin, switch paths to Windows format before running java
114 | if $cygwin ; then
115 |     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
116 |     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
117 | 
118 |     # We build the pattern for arguments to be converted via cygpath
119 |     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
120 |     SEP=""
121 |     for dir in $ROOTDIRSRAW ; do
122 |         ROOTDIRS="$ROOTDIRS$SEP$dir"
123 |         SEP="|"
124 |     done
125 |     OURCYGPATTERN="(^($ROOTDIRS))"
126 |     # Add a user-defined pattern to the cygpath arguments
127 |     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
128 |         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
129 |     fi
130 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
131 |     i=0
132 |     for arg in "$@" ; do
133 |         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
134 |         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
135 | 
136 |         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
137 |             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
138 |         else
139 |             eval `echo args$i`="\"$arg\""
140 |         fi
141 |         i=$((i+1))
142 |     done
143 |     case $i in
144 |         (0) set -- ;;
145 |         (1) set -- "$args0" ;;
146 |         (2) set -- "$args0" "$args1" ;;
147 |         (3) set -- "$args0" "$args1" "$args2" ;;
148 |         (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
149 |         (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
150 |         (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
151 |         (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
152 |         (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
153 |         (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
154 |     esac
155 | fi
156 | 
157 | # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
158 | function splitJvmOpts() {
159 |     JVM_OPTS=("$@")
160 | }
161 | eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
162 | JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
163 | 
164 | exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
165 | 


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/JavaCardBuildTaskTest.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The MIT License (MIT)
  3 |  * <p/>
  4 |  * Copyright (c) 2017-2018 Bertrand Martel
  5 |  * <p/>
  6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7 |  * of this software and associated documentation files (the "Software"), to deal
  8 |  * in the Software without restriction, including without limitation the rights
  9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 |  * copies of the Software, and to permit persons to whom the Software is
 11 |  * furnished to do so, subject to the following conditions:
 12 |  * <p/>
 13 |  * The above copyright notice and this permission notice shall be included in
 14 |  * all copies or substantial portions of the Software.
 15 |  * <p/>
 16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 |  * THE SOFTWARE.
 23 |  */
 24 | 
 25 | package com.klinec.gradle.javacard
 26 | 
 27 | import com.klinec.gradle.javacard.common.CommonTest
 28 | import com.klinec.gradle.javacard.utils.TestUtils
 29 | import org.gradle.api.ProjectConfigurationException
 30 | import org.junit.Test
 31 | 
 32 | /**
 33 |  * JavaCard task test.
 34 |  *
 35 |  * @author Bertrand Martel
 36 |  */
 37 | class JavaCardBuildTaskTest extends CommonTest {
 38 | 
 39 |     Closure buildSdkConf(sdk, appletName, verify_=true) {
 40 |         return {
 41 |             config {
 42 |                 cap {
 43 |                     jckit sdk
 44 |                     packageName 'fr.bmartel.javacard'
 45 |                     version '0.1'
 46 |                     aid '01:02:03:04:05:06:07:08:09'
 47 |                     output appletName + '.cap'
 48 |                     verify verify_
 49 |                     applet {
 50 |                         className 'fr.bmartel.javacard.HelloWorld'
 51 |                         aid '01:02:03:04:05:06:07:08:09:01:02'
 52 |                     }
 53 |                     dependencies {
 54 |                     }
 55 |                 }
 56 |             }
 57 |         }
 58 |     }
 59 | 
 60 |     @Test
 61 |     void validBuild() {
 62 |         runBuildTask(StaticConfig.VALID_CONFIG)
 63 |     }
 64 | 
 65 |     @Test
 66 |     void simpleBuild() {
 67 |         runBuildTask(StaticConfig.SIMPLE_CONFIG)
 68 |     }
 69 | 
 70 |     @Test
 71 |     void validBuildFullOutput() {
 72 |         runBuildTask(StaticConfig.FULL_OUTPUT)
 73 |     }
 74 | 
 75 |     @Test
 76 |     void multipleCaps() {
 77 |         runBuildTask(StaticConfig.MULTIPLE_CAPS)
 78 |     }
 79 | 
 80 |     @Test
 81 |     void multipleApplets() {
 82 |         runBuildTask(StaticConfig.MULTIPLE_APPLETS)
 83 |     }
 84 | 
 85 |     @Test
 86 |     void sdkVersion212() {
 87 |         if (TestUtils.compareJdk(System.getProperty("java.version"), "1.9") < 0) {
 88 |             runBuildTask(buildSdkConf(StaticConfig.getSdkPath("jc212_kit"), "applet", false))
 89 |         }
 90 |     }
 91 | 
 92 |     @Test
 93 |     void sdkVersion221() {
 94 |         if (TestUtils.compareJdk(System.getProperty("java.version"), "1.9") < 0) {
 95 |             runBuildTask(buildSdkConf(StaticConfig.getSdkPath("jc221_kit"), "applet"))
 96 |         }
 97 |     }
 98 | 
 99 |     @Test
100 |     void sdkVersion222() {
101 |         if (TestUtils.compareJdk(System.getProperty("java.version"), "1.9") < 0) {
102 |             runBuildTask(buildSdkConf(StaticConfig.getSdkPath("jc222_kit"), "applet1"))
103 |         }
104 |     }
105 | 
106 | 
107 |     @Test
108 |     void sdkVersion303() {
109 |         if (TestUtils.compareJdk(System.getProperty("java.version"), "12") < 0) {
110 |             runBuildTask(buildSdkConf(StaticConfig.getSdkPath("jc303_kit"), "applet2"))
111 |         }
112 |     }
113 | 
114 |     @Test
115 |     void sdkVersion304() {
116 |         if (TestUtils.compareJdk(System.getProperty("java.version"), "12") < 0) {
117 |             runBuildTask(buildSdkConf(StaticConfig.getSdkPath("jc304_kit"), "applet3"))
118 |         }
119 |     }
120 | 
121 |     @Test
122 |     void sdkVersion305u1() {
123 |         if (TestUtils.compareJdk(System.getProperty("java.version"), "12") < 0) {
124 |             runBuildTask(buildSdkConf(StaticConfig.getSdkPath("jc305u1_kit"), "applet4"))
125 |         }
126 |     }
127 | 
128 |     @Test
129 |     void sdkVersion31() {
130 |         if (TestUtils.compareJdk(System.getProperty("java.version"), "15") < 0) {
131 |             runBuildTask(buildSdkConf(StaticConfig.getSdkPath("jc310b43_kit"), "applet5"))
132 |         }
133 |     }
134 | 
135 |     @Test(expected = ProjectConfigurationException.class)
136 |     void jckitPathUndefinedError() {
137 |         runBuildTask(StaticConfig.UNDEFINED_JCKIT_PATH)
138 |     }
139 | 
140 |     @Test(expected = ProjectConfigurationException.class)
141 |     void jckitPathInvalidError() {
142 |         runBuildTask(StaticConfig.INVALID_JCKIT_PATH)
143 |     }
144 | 
145 |     @Test(expected = ProjectConfigurationException.class)
146 |     void outputRequiredError() {
147 |         runBuildTask(StaticConfig.OUTPUT_REQUIRED)
148 |     }
149 | 
150 |     @Test(expected = ProjectConfigurationException.class)
151 |     void appletClassNameRequiredError() {
152 |         runBuildTask(StaticConfig.APPLET_CLASSNAME_REQUIRED)
153 |     }
154 | 
155 |     @Test(expected = ProjectConfigurationException.class)
156 |     void missingAllCapAttributesError() {
157 |         runBuildTask(StaticConfig.MISSING_ALL_CAPS)
158 |     }
159 | 
160 |     @Test(expected = ProjectConfigurationException.class)
161 |     void noFieldsError() {
162 |         runBuildTask(StaticConfig.NO_FIELDS)
163 |     }
164 | }


--------------------------------------------------------------------------------
/gradle-javacard/build.gradle:
--------------------------------------------------------------------------------
  1 | //apply plugin: 'com.github.dcendents.android-maven'
  2 | //apply plugin: 'com.jfrog.bintray'
  3 | plugins {
  4 |     id "groovy"
  5 |     id "com.gradle.plugin-publish" version "0.11.0"
  6 |     id "java-gradle-plugin"
  7 | }
  8 | 
  9 | group 'com.klinec'
 10 | version '1.8.0'
 11 | 
 12 | apply plugin: 'maven'
 13 | apply plugin: 'signing'
 14 | 
 15 | targetCompatibility = '1.8'
 16 | sourceCompatibility = '1.8'
 17 | 
 18 | repositories {
 19 |     jcenter()
 20 |     mavenCentral()
 21 |     maven {
 22 |         url "https://javacard.pro/maven"
 23 |     }
 24 |     maven {
 25 |         url "https://deadcode.me/mvn"
 26 |     }
 27 |     //mavenLocal()
 28 | }
 29 | 
 30 | dependencies {
 31 |     api gradleApi()
 32 |     implementation localGroovy()
 33 |     implementation 'com.github.martinpaljak:ant-javacard:20.03.25'
 34 |     implementation 'com.github.martinpaljak:gppro:20.08.12'
 35 |     implementation 'com.github.martinpaljak:gptool:20.08.12'
 36 |     implementation 'com.github.martinpaljak:globalplatformpro:20.08.12'
 37 | 
 38 |     testImplementation 'junit:junit:4.12'
 39 |     testImplementation 'org.hamcrest:hamcrest-all:1.3'
 40 | }
 41 | 
 42 | def siteUrl = 'https://github.com/ph4r05/javacard-gradle-plugin'
 43 | def gitUrl = 'https://github.com/ph4r05/javacard-gradle-plugin.git'
 44 | 
 45 | signing {
 46 |     required {
 47 |         gradle.taskGraph.hasTask("uploadArchives")
 48 |     }
 49 |     sign configurations.archives
 50 | }
 51 | 
 52 | // When uploading setup your ~/.gradle/gradle.properties
 53 | uploadArchives {
 54 |     repositories {
 55 |         mavenDeployer {
 56 |             beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
 57 | 
 58 |             repository(url: "https://oss.sonatype.org/service/local/staging/deploy/maven2/") {
 59 |                 authentication(userName: project.findProperty('ossrhUsername'), password: project.findProperty('ossrhPassword'))
 60 |             }
 61 | 
 62 |             snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
 63 |                 authentication(userName: project.findProperty('ossrhUsername'), password: project.findProperty('ossrhPassword'))
 64 |             }
 65 | 
 66 |             pom.project {
 67 |                 name 'gradle-javacard'
 68 |                 packaging 'jar'
 69 | 
 70 |                 description 'Gradle JavaCard plugin'
 71 |                 url 'https://github.com/ph4r05/javacard-gradle-plugin'
 72 | 
 73 |                 scm {
 74 |                     connection 'scm:git:git://github.com/ph4r05/javacard-gradle-plugin'
 75 |                     developerConnection 'scm:git:git@github.com:ph4r05/javacard-gradle-plugin.git'
 76 |                     url 'https://github.com/ph4r05/javacard-gradle-plugin'
 77 |                 }
 78 | 
 79 |                 licenses {
 80 |                     license {
 81 |                         name 'MIT'
 82 |                         url 'https://raw.githubusercontent.com/ph4r05/javacard-gradle-plugin/master/LICENSE'
 83 |                     }
 84 |                 }
 85 | 
 86 |                 developers {
 87 |                     developer {
 88 |                         id 'ph4r05'
 89 |                         name 'Dusan Klinec'
 90 |                         email 'dusan.klinec@gmail.com'
 91 |                     }
 92 |                     developer {
 93 |                         id 'bertrandmartel'
 94 |                         name 'Bertrand Martel'
 95 |                         email 'bmartel.fr@gmail.com'
 96 |                     }
 97 |                 }
 98 |             }
 99 |         }
100 |     }
101 | }
102 | 
103 | 
104 | sourceSets {
105 |     main {
106 |         java {
107 |             srcDirs = [
108 | //                    'src/main/java/ant-javacard/src/main/java',
109 | //                    'src/main/java/global-platform-pro/src/main/java',
110 | //                    'src/main/java/apdu4j/src',
111 | //                    'src/main/java/jnasmartcardio/src/main/java'
112 |             ]
113 |             exclude '**/testapplets/**'
114 |         }
115 |     }
116 | }
117 | 
118 | Object.metaClass.notIn = { Object collection ->
119 |     !(delegate in collection)
120 | }
121 | 
122 | task sourcesJar(type: Jar, dependsOn: classes) {
123 |     classifier = 'sources'
124 |     from sourceSets.main.allSource
125 | }
126 | 
127 | task groovydocJar(type: Jar, dependsOn: groovydoc) {
128 |     classifier = 'javadoc'
129 |     from groovydoc.destinationDir
130 | }
131 | 
132 | artifacts {
133 |     archives sourcesJar
134 |     archives groovydocJar
135 | }
136 | 
137 | gradlePlugin {
138 |     plugins {
139 |         javacard {
140 |             id = 'com.klinec.gradle.javacard'
141 |             implementationClass = 'com.klinec.gradle.javacard.JavaCardPlugin'
142 |         }
143 |     }
144 | }
145 | 
146 | pluginBundle {
147 |     website = 'https://github.com/ph4r05/javacard-gradle-plugin'
148 |     vcsUrl = 'https://github.com/ph4r05/javacard-gradle-plugin'
149 |     description = 'Gradle JavaCard plugin'
150 |     tags = ['javacard']
151 | 
152 |     plugins {
153 |         javacard {
154 |             displayName = 'Gradle JavaCard plugin'
155 |         }
156 |     }
157 | }
158 | 
159 | task generateJavadoc(type: Javadoc) {
160 |     source = sourceSets.main.allJava
161 |     classpath = configurations.compile
162 |     destinationDir = file("./doc/")
163 | }
164 | 
165 | tasks.jar {
166 |     manifest {
167 |         attributes('Automatic-Module-Name': 'com.klinec.gradle.javacard')
168 |     }
169 | }
170 | 
171 | compileJava {
172 |     sourceCompatibility = "1.7"
173 |     targetCompatibility = "1.7"
174 |     options.encoding = 'UTF-8'
175 |     options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation"
176 | }
177 | 
178 | compileTestJava {
179 |     options.encoding = 'UTF-8'
180 |     options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation"
181 | }
182 | 
183 | test {
184 |     testLogging.showStandardStreams = true
185 | }
186 | 
187 | if (JavaVersion.current().isJava8Compatible()) {
188 |     allprojects {
189 |         tasks.withType(Javadoc) {
190 |             options.addStringOption('Xdoclint:none', '-quiet')
191 |         }
192 |     }
193 | }
194 | 


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Cap.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The MIT License (MIT)
  3 |  * <p/>
  4 |  * Copyright (c) 2017 Bertrand Martel
  5 |  * <p/>
  6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7 |  * of this software and associated documentation files (the "Software"), to deal
  8 |  * in the Software without restriction, including without limitation the rights
  9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 |  * copies of the Software, and to permit persons to whom the Software is
 11 |  * furnished to do so, subject to the following conditions:
 12 |  * <p/>
 13 |  * The above copyright notice and this permission notice shall be included in
 14 |  * all copies or substantial portions of the Software.
 15 |  * <p/>
 16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 |  * THE SOFTWARE.
 23 |  */
 24 | 
 25 | package com.klinec.gradle.javacard.extension
 26 | 
 27 | import org.gradle.api.Action
 28 | import org.gradle.api.model.ObjectFactory
 29 | import org.gradle.util.ClosureBackedAction
 30 | 
 31 | import javax.inject.Inject
 32 | 
 33 | /**
 34 |  * Cap extension object (the same as defined in https://github.com/martinpaljak/ant-javacard#syntax
 35 |  *
 36 |  * @author Bertrand Martel
 37 |  */
 38 | abstract class Cap {
 39 | 
 40 |     /**
 41 |      * path to the JavaCard SDK to be used for this CAP. Optional if javacard defines one, required otherwise.
 42 |      */
 43 |     String jckit
 44 | 
 45 |     /**
 46 |      * path to the target JavaCard SDK to be used for this CAP. Optional, value of jckit used by default.
 47 |      * Allows to use a more recent converter to target older JavaCard platforms.
 48 |      */
 49 |     String targetsdk
 50 | 
 51 |     /**
 52 |      * path to Java source code, to be compiled against the current JavaCard SDK. Either sources or classes is required.
 53 |      */
 54 |     String sources
 55 | 
 56 |     /**
 57 |      * additional sources to build per-platform applets. Optional.
 58 |      */
 59 |     String sources2
 60 | 
 61 |     /**
 62 |      * If true the sources are determined automatically. The first existing source dir in source sets is taken.
 63 |      */
 64 |     boolean findSources = true
 65 | 
 66 |     /**
 67 |      * if true the first source dir from the source set is used. Otherwise the most recet (last).
 68 |      */
 69 |     boolean defaultSources = true
 70 | 
 71 |     /**
 72 |      * path to pre-compiled class files to be assembled into a CAP file. If both classes and sources are specified,
 73 |      * compiled class files will be put to classes folder, which is created if missing.
 74 |      */
 75 |     String classes
 76 | 
 77 |     /**
 78 |      * comma or space separated list of patterns of files that must be included.
 79 |      */
 80 |     String include
 81 | 
 82 |     /**
 83 |      * comma or space separated list of patterns of files that must be excluded.
 84 |      */
 85 |     String exclude
 86 | 
 87 |     /**
 88 |      * name of the package of the CAP file. Optional - set to the parent package of the applet class if left unspecified.
 89 |      */
 90 |     String packageName
 91 | 
 92 |     /**
 93 |      * version of the package. Optional - defaults to 0.0 if left unspecified.
 94 |      */
 95 |     String version
 96 | 
 97 |     /**
 98 |      * AID (hex) of the package. Recommended - or set to the 5 first bytes of the applet AID if left unspecified.
 99 |      */
100 |     String aid
101 | 
102 |     /**
103 |      * path where to save the generated CAP file. Required.
104 |      */
105 |     String output
106 | 
107 |     /**
108 |      * path (folder) where to place the JAR and generated EXP file. Optional.
109 |      */
110 |     String export
111 | 
112 |     /**
113 |      * path (folder) where to place the JAR and generated EXP file. Optional.
114 |      */
115 |     String jar
116 | 
117 |     /**
118 |      * path where to save the generated JavaCard Assembly (JCA) file. Optional.
119 |      */
120 |     String jca
121 | 
122 |     /**
123 |      * if set to false, disables verification of the resulting CAP file with offcardeverifier. Optional.
124 |      */
125 |     boolean verify = true
126 | 
127 |     /**
128 |      * if set to true, generates debug CAP components. Optional.
129 |      */
130 |     boolean debug = false
131 | 
132 |     /**
133 |      * if set to true, enables support for 32 bit int type. Optional.
134 |      */
135 |     boolean ints = false
136 | 
137 |     /**
138 |      * override the Java source and target version. Optional.
139 |      */
140 |     String javaversion
141 | 
142 |     /**
143 |      * list of applets.
144 |      */
145 |     List<Applet> applets = []
146 | 
147 |     /**
148 |      * dependencies
149 |      */
150 |     Dependencies dependencies
151 | 
152 |     Applet applet(Closure closure) {
153 |         applet(ClosureBackedAction.of(closure))
154 |     }
155 | 
156 |     Applet applet(Action<Applet> action) {
157 |         def someApplet = objectFactory.newInstance(Applet)
158 |         action.execute(someApplet)
159 |         applets.add(someApplet)
160 |         someApplet
161 |     }
162 | 
163 |     void dependencies(Closure closure) {
164 |         dependencies(ClosureBackedAction.of(closure))
165 |     }
166 | 
167 |     void dependencies(Action<Dependencies> action) {
168 |         def dependency = objectFactory.newInstance(Dependencies)
169 |         action.execute(dependency)
170 |         dependencies = dependency
171 |         dependency
172 |     }
173 | 
174 |     void jckit(String path) {
175 |         this.jckit = path
176 |     }
177 | 
178 |     void targetsdk(String path) {
179 |         this.targetsdk = path
180 |     }
181 | 
182 |     void sources(String path) {
183 |         this.sources = path
184 |     }
185 | 
186 |     void sources2(String path) {
187 |         this.sources2 = path
188 |     }
189 | 
190 |     void findSources(Boolean findSources) {
191 |         this.findSources = findSources
192 |     }
193 | 
194 |     void defaultSources(Boolean defaultSources) {
195 |         this.defaultSources = defaultSources
196 |     }
197 | 
198 |     void packageName(String packageName) {
199 |         this.packageName = packageName
200 |     }
201 | 
202 |     void version(String version) {
203 |         this.version = version
204 |     }
205 | 
206 |     void aid(String aid) {
207 |         this.aid = aid
208 |     }
209 | 
210 |     void include(String include) {
211 |         this.include = include
212 |     }
213 | 
214 |     void exclude(String exclude) {
215 |         this.exclude = exclude
216 |     }
217 | 
218 |     void output(String output) {
219 |         this.output = output
220 |     }
221 | 
222 |     void export(String export) {
223 |         this.export = export
224 |     }
225 | 
226 |     void jar(String jar) {
227 |         this.jar = jar
228 |     }
229 | 
230 |     void jca(String jca) {
231 |         this.jca = jca
232 |     }
233 | 
234 |     void verify(boolean verify) {
235 |         this.verify = verify
236 |     }
237 | 
238 |     void debug(boolean debug) {
239 |         this.debug = debug
240 |     }
241 | 
242 |     void ints(boolean ints) {
243 |         this.ints = ints
244 |     }
245 | 
246 |     void javaversion(String javaversion) {
247 |         this.javaversion = javaversion
248 |     }
249 | 
250 |     @Inject
251 |     abstract ObjectFactory getObjectFactory()
252 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/extension/Config.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The MIT License (MIT)
  3 |  * <p/>
  4 |  * Copyright (c) 2017 Bertrand Martel
  5 |  * <p/>
  6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7 |  * of this software and associated documentation files (the "Software"), to deal
  8 |  * in the Software without restriction, including without limitation the rights
  9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 |  * copies of the Software, and to permit persons to whom the Software is
 11 |  * furnished to do so, subject to the following conditions:
 12 |  * <p/>
 13 |  * The above copyright notice and this permission notice shall be included in
 14 |  * all copies or substantial portions of the Software.
 15 |  * <p/>
 16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 |  * THE SOFTWARE.
 23 |  */
 24 | 
 25 | package com.klinec.gradle.javacard.extension
 26 | 
 27 | import org.gradle.api.Action
 28 | import org.gradle.api.InvalidUserDataException
 29 | import org.gradle.api.Project
 30 | import org.gradle.api.model.ObjectFactory
 31 | import org.gradle.util.ClosureBackedAction
 32 | 
 33 | import javax.inject.Inject
 34 | 
 35 | /**
 36 |  * JavaCard extension object (the same as defined in https://github.com/martinpaljak/ant-javacard#syntax
 37 |  *
 38 |  * @author Bertrand Martel
 39 |  */
 40 | abstract class Config {
 41 | 
 42 |     /**
 43 |      * path to the JavaCard SDK that is used if individual cap does not specify one. Optional if cap defines one, required otherwise.
 44 |      */
 45 |     String jckit
 46 | 
 47 |     Object jcardSim
 48 | 
 49 |     Object gptoolVersion
 50 | 
 51 |     /**
 52 |      * @deprecated Has no effect, will be removed in future release
 53 |      */
 54 |     boolean addSurrogateJcardSimRepo = false
 55 | 
 56 |     boolean addImplicitJcardSim = true
 57 | 
 58 |     boolean addImplicitJcardSimJunit = true
 59 | 
 60 |     boolean debugGpPro = false
 61 | 
 62 |     boolean fixClassPath = true
 63 | 
 64 |     /**
 65 |      * log level to set to "VERBOSE","DEBUG","INFO","WARN" or "ERROR", default is "INFO"
 66 |      */
 67 |     String logLevel = 'INFO'
 68 | 
 69 |     /**
 70 |      * Classpath for Ant
 71 |      */
 72 |     String antClassPath = null
 73 | 
 74 |     /**
 75 |      * list of cap files to build.
 76 |      */
 77 |     List<Cap> caps = []
 78 | 
 79 |     /**
 80 |      * list of additional GPPro args for the install task
 81 |      */
 82 |     List<String> installGpProArgs = []
 83 | 
 84 |     Cap cap(Closure closure) {
 85 |         cap(ClosureBackedAction.of(closure))
 86 |     }
 87 | 
 88 |     Cap cap(Action<Cap> action) {
 89 |         def someCap = objectFactory.newInstance(Cap)
 90 |         action.execute(someCap)
 91 |         caps.add(someCap)
 92 |         return someCap
 93 |     }
 94 | 
 95 |     void installGpProArgs(String arg) {
 96 |         this.installGpProArgs.add(arg)
 97 |     }
 98 | 
 99 |     void jckit(String path) {
100 |         this.jckit = path
101 |     }
102 | 
103 |     void antClassPath(String classPath) {
104 |         this.antClassPath = classPath
105 |     }
106 | 
107 |     void logLevel(String logLevel) {
108 |         this.logLevel = logLevel
109 |     }
110 | 
111 |     void jcardSim(Object jcardSim) {
112 |         this.jcardSim = jcardSim
113 |     }
114 | 
115 |     /**
116 |      * @deprecated Has no effect, will be removed in future release
117 |      */
118 |     void addSurrogateJcardSimRepo(Boolean addIt) {
119 |         this.addSurrogateJcardSimRepo = addIt
120 |     }
121 | 
122 |     void addImplicitJcardSim(Boolean addIt) {
123 |         this.addImplicitJcardSim = addIt
124 |     }
125 | 
126 |     void addImplicitJcardSimJunit(Boolean addIt) {
127 |         this.addImplicitJcardSimJunit = addIt
128 |     }
129 | 
130 |     void debugGpPro(Boolean val) {
131 |         this.debugGpPro = val
132 |     }
133 | 
134 |     void fixClassPath(Boolean val) {
135 |         this.fixClassPath = val
136 |     }
137 | 
138 |     /**
139 |      * Validate fields
140 |      */
141 |     def validate(Project project) {
142 |         checkJckit(project)
143 |         checkOutput()
144 |         checkAppletClass()
145 |         checkDependency()
146 |     }
147 | 
148 |     /**
149 |      * Check that an exp is defined for import object nested in cap.
150 |      */
151 |     def checkDependency() {
152 |         caps.each { capItem ->
153 |             if (capItem.dependencies != null) {
154 |                 capItem.dependencies.local.each { importItem ->
155 |                     if (!importItem.exps?.trim() || !importItem.jar?.trim()) {
156 |                         throw new InvalidUserDataException('import exp/jar is required for local dependency')
157 |                     }
158 |                 }
159 |             }
160 |         }
161 |     }
162 | 
163 |     /**
164 |      * Check that a className is defined for each applet nested in cap.
165 |      */
166 |     def checkAppletClass() {
167 |         caps.each { capItem ->
168 |             capItem.applets.each { appletItem ->
169 |                 if (!appletItem.className?.trim()) {
170 |                     throw new InvalidUserDataException('applet className is required')
171 |                 }
172 |             }
173 |         }
174 |     }
175 | 
176 |     /**
177 |      * Check that output field is defined.
178 |      */
179 |     def checkOutput() {
180 |         caps.each { capItem ->
181 |             if (!capItem.output?.trim()) {
182 |                 throw new InvalidUserDataException('cap output is required')
183 |             }
184 |         }
185 |     }
186 | 
187 |     /**
188 |      * Check that jckit is defined either in the root javacard object or in all caps object if not in environment variable.
189 |      */
190 |     def checkJckit(Project project) {
191 |         if (jckit?.trim()) {
192 |             def folder = project.file(jckit)
193 |             if (!folder.exists()) {
194 |                 throw new InvalidUserDataException('Invalid JavaCard SDK path : ' + folder.getAbsolutePath())
195 |             }
196 |             jckit = folder.getAbsolutePath()
197 |         } else if (caps.size() > 0) {
198 |             caps.each { capItem ->
199 |                 if (!capItem.jckit?.trim() && !System.env['JC_HOME']) {
200 |                     throw new InvalidUserDataException('Invalid JavaCard SDK path : use JC_HOME or jckit')
201 |                 } else if (capItem.jckit?.trim() && !System.env['JC_HOME']) {
202 |                     def folder = project.file(capItem.jckit)
203 |                     if (!folder.exists()) {
204 |                         throw new InvalidUserDataException('Invalid JavaCard SDK path : ' + folder.getAbsolutePath())
205 |                     }
206 |                     capItem.jckit = folder.getAbsolutePath()
207 |                 }
208 |             }
209 |         } else {
210 |             throw new InvalidUserDataException('no caps were referenced')
211 |         }
212 |     }
213 | 
214 |     /**
215 |      * Get Javacard SDK
216 |      * @return
217 |      */
218 |     String getJcKit() {
219 |         if (System.env['JC_HOME']) {
220 |             return System.env['JC_HOME']
221 |         } else if (jckit?.trim()) {
222 |             return jckit
223 |         } else if (caps.size() > 0) {
224 |             def kit = ""
225 |             caps.each { capItem ->
226 |                 if (capItem.jckit?.trim()) {
227 |                     kit = capItem.jckit
228 |                 }
229 |             }
230 |             return kit
231 |         }
232 |         return ""
233 |     }
234 | 
235 |     @Inject
236 |     abstract ObjectFactory getObjectFactory()
237 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/JavaCardPluginTest.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The MIT License (MIT)
  3 |  * <p/>
  4 |  * Copyright (c) 2017 Bertrand Martel
  5 |  * <p/>
  6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7 |  * of this software and associated documentation files (the "Software"), to deal
  8 |  * in the Software without restriction, including without limitation the rights
  9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 |  * copies of the Software, and to permit persons to whom the Software is
 11 |  * furnished to do so, subject to the following conditions:
 12 |  * <p/>
 13 |  * The above copyright notice and this permission notice shall be included in
 14 |  * all copies or substantial portions of the Software.
 15 |  * <p/>
 16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 |  * THE SOFTWARE.
 23 |  */
 24 | 
 25 | package com.klinec.gradle.javacard
 26 | 
 27 | import org.gradle.api.Project
 28 | import org.gradle.testfixtures.ProjectBuilder
 29 | import org.junit.BeforeClass
 30 | import org.junit.Test
 31 | 
 32 | import static org.junit.Assert.assertEquals
 33 | import static org.hamcrest.Matchers.*
 34 | import static org.junit.Assert.assertThat
 35 | 
 36 | /**
 37 |  * JavaCard plugin test.
 38 |  *
 39 |  * @author Bertrand Martel
 40 |  */
 41 | class JavaCardPluginTest {
 42 | 
 43 |     private static Project project
 44 | 
 45 |     def projectTest = [
 46 |             jckit  : '/path/to/project/jckit',
 47 |             caps   : [
 48 |                     cap1: [
 49 |                             jckit       : '/path/to/jckit',
 50 |                             sources     : '/path/to/sources',
 51 |                             packageName : 'some.package.name',
 52 |                             version     : '1.0',
 53 |                             aid         : '0x01:0x02:0x03:0x04:0x05',
 54 |                             output      : '/path/to/output',
 55 |                             export      : '/path/to/export',
 56 |                             jca         : '/path/to/jca',
 57 |                             verify      : false,
 58 |                             debug       : true,
 59 |                             ints        : false,
 60 |                             dependencies: [
 61 |                                     local : [
 62 |                                             exps: '/path/to/exps',
 63 |                                             jar : '/path/to/jar'
 64 |                                     ],
 65 |                                     remote: 'fr.bmartel:gplatform:1.6'
 66 |                             ],
 67 |                             applets     : [
 68 |                                     applet1: [
 69 |                                             className: 'some.class.applet1',
 70 |                                             aid      : '0x01:0x02:0x03:0x04:0x05:0x01'
 71 |                                     ],
 72 |                                     applet2: [
 73 |                                             className: 'some.class.applet2',
 74 |                                             aid      : '0x01:0x02:0x03:0x04:0x05:0x02'
 75 |                                     ]
 76 |                             ]
 77 |                     ]
 78 |             ],
 79 |             scripts: [
 80 |                     script1: [
 81 |                             name: 'script1',
 82 |                             apdu: '010203'
 83 |                     ],
 84 |                     script2: [
 85 |                             name: 'script2',
 86 |                             apdu: '040506'
 87 |                     ],
 88 |                     task1  : [
 89 |                             name   : 'task1',
 90 |                             scripts: ['script1', 'script2']
 91 |                     ],
 92 |                     task2  : [
 93 |                             name   : 'task2',
 94 |                             scripts: ['script1', 'script2']
 95 |                     ]
 96 |             ],
 97 |             test   : [
 98 |                     dependencies:
 99 |                             [
100 |                                     'junit:junit:4.12',
101 |                                     'com.licel:jcardsim:3.0.4'
102 |                             ]
103 |             ]
104 |     ]
105 | 
106 |     @BeforeClass
107 |     static void setUpProject() {
108 |         project = ProjectBuilder.builder().build()
109 |         project.apply plugin: 'javacard'
110 |     }
111 | 
112 |     @Test
113 |     void addBuildTask() {
114 |         def task = project.getTasks().findByPath('buildJavaCard')
115 |         assertThat(task, instanceOf(JavaCardBuildTask))
116 |         assertThat(task.group, equalTo('build'))
117 |     }
118 | 
119 |     @Test
120 |     void checkExtensionValues() {
121 |         project.configure(project.javacard) {
122 |             config {
123 |                 jckit projectTest.jckit
124 |                 cap {
125 |                     jckit projectTest.caps.cap1.jckit
126 |                     sources projectTest.caps.cap1.sources
127 |                     packageName projectTest.caps.cap1.packageName
128 |                     version projectTest.caps.cap1.version
129 |                     aid projectTest.caps.cap1.aid
130 |                     output projectTest.caps.cap1.output
131 |                     export projectTest.caps.cap1.export
132 |                     jca projectTest.caps.cap1.jca
133 |                     verify projectTest.caps.cap1.verify
134 |                     debug projectTest.caps.cap1.debug
135 |                     ints projectTest.caps.cap1.ints
136 |                     applet {
137 |                         className projectTest.caps.cap1.applets.applet1.className
138 |                         aid projectTest.caps.cap1.applets.applet1.aid
139 |                     }
140 |                     applet {
141 |                         className projectTest.caps.cap1.applets.applet2.className
142 |                         aid projectTest.caps.cap1.applets.applet2.aid
143 |                     }
144 |                     dependencies {
145 |                         remote projectTest.caps.cap1.dependencies.remote
146 |                         local {
147 |                             exps projectTest.caps.cap1.dependencies.local.exps
148 |                             jar projectTest.caps.cap1.dependencies.local.jar
149 |                         }
150 |                     }
151 |                 }
152 |             }
153 | 
154 |             test {
155 |                 dependencies {
156 |                     compile 'junit:junit:4.12'
157 |                     compile 'com.licel:jcardsim:3.0.4'
158 |                 }
159 |             }
160 | 
161 |             defaultKey '39:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
162 | 
163 |             key {
164 |                 enc '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
165 |                 dek '50:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
166 |                 mac '60:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
167 |             }
168 | 
169 |             scripts {
170 | 
171 |                 script {
172 |                     name projectTest.scripts.script1.name
173 |                     apdu projectTest.scripts.script1.apdu
174 |                 }
175 | 
176 |                 script {
177 |                     name projectTest.scripts.script2.name
178 |                     apdu projectTest.scripts.script2.apdu
179 |                 }
180 | 
181 |                 task {
182 |                     name projectTest.scripts.task1.name
183 |                     scripts projectTest.scripts.task1.scripts[0], projectTest.scripts.task1.scripts[1]
184 |                 }
185 | 
186 |                 task {
187 |                     name projectTest.scripts.task2.name
188 |                     scripts projectTest.scripts.task2.scripts[0], projectTest.scripts.task2.scripts[1]
189 |                 }
190 |             }
191 |         }
192 | 
193 |         JavaCardBuildTask task = project.getTasks().findByPath('buildJavaCard')
194 |         assertEquals(task.getJavaCard().config.jckit, projectTest.jckit)
195 |         assertEquals(task.getJavaCard().config.caps.size(), 1)
196 |         assertEquals(task.getJavaCard().config.caps[0].jckit, projectTest.caps.cap1.jckit)
197 |         assertEquals(task.getJavaCard().config.caps[0].sources, projectTest.caps.cap1.sources)
198 |         assertEquals(task.getJavaCard().config.caps[0].packageName, projectTest.caps.cap1.packageName)
199 |         assertEquals(task.getJavaCard().config.caps[0].version, projectTest.caps.cap1.version)
200 |         assertEquals(task.getJavaCard().config.caps[0].aid, projectTest.caps.cap1.aid)
201 |         assertEquals(task.getJavaCard().config.caps[0].output, projectTest.caps.cap1.output)
202 |         assertEquals(task.getJavaCard().config.caps[0].export, projectTest.caps.cap1.export)
203 |         assertEquals(task.getJavaCard().config.caps[0].jca, projectTest.caps.cap1.jca)
204 |         assertEquals(task.getJavaCard().config.caps[0].verify, projectTest.caps.cap1.verify)
205 |         assertEquals(task.getJavaCard().config.caps[0].debug, projectTest.caps.cap1.debug)
206 |         assertEquals(task.getJavaCard().config.caps[0].ints, projectTest.caps.cap1.ints)
207 |         assertEquals(task.getJavaCard().config.caps[0].applets.size(), 2)
208 |         assertEquals(task.getJavaCard().config.caps[0].applets[0].className, projectTest.caps.cap1.applets.applet1.className)
209 |         assertEquals(task.getJavaCard().config.caps[0].applets[0].aid, projectTest.caps.cap1.applets.applet1.aid)
210 |         assertEquals(task.getJavaCard().config.caps[0].applets[1].className, projectTest.caps.cap1.applets.applet2.className)
211 |         assertEquals(task.getJavaCard().config.caps[0].applets[1].aid, projectTest.caps.cap1.applets.applet2.aid)
212 |         assertEquals(task.getJavaCard().config.caps[0].dependencies.local[0].exps, projectTest.caps.cap1.dependencies.local.exps)
213 |         assertEquals(task.getJavaCard().config.caps[0].dependencies.local[0].jar, projectTest.caps.cap1.dependencies.local.jar)
214 |         assertEquals(task.getJavaCard().config.caps[0].dependencies.local.size(), 1)
215 |         assertEquals(task.getJavaCard().config.caps[0].dependencies.remote[0], projectTest.caps.cap1.dependencies.remote)
216 |         assertEquals(task.getJavaCard().config.caps[0].dependencies.remote.size(), 1)
217 |         assertEquals(task.getJavaCard().scripts.scripts.size(), 2)
218 |         assertEquals(task.getJavaCard().scripts.tasks.size(), 2)
219 | 
220 |         assertEquals(task.getJavaCard().defaultKey, '39:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F')
221 | 
222 |         assertEquals(task.getJavaCard().key.keyEnc, '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F')
223 |         assertEquals(task.getJavaCard().key.keyDek, '50:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F')
224 |         assertEquals(task.getJavaCard().key.keyMac, '60:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F')
225 | 
226 |         assertEquals(task.getJavaCard().scripts.scripts[0].name, projectTest.scripts.script1.name)
227 |         assertEquals(task.getJavaCard().scripts.scripts[0].apdu, projectTest.scripts.script1.apdu)
228 |         assertEquals(task.getJavaCard().scripts.scripts[1].name, projectTest.scripts.script2.name)
229 |         assertEquals(task.getJavaCard().scripts.scripts[1].apdu, projectTest.scripts.script2.apdu)
230 | 
231 |         assertEquals(task.getJavaCard().scripts.tasks[0].name, projectTest.scripts.task1.name)
232 |         assertEquals(task.getJavaCard().scripts.tasks[0].scripts.size(), 2)
233 |         assertEquals(task.getJavaCard().scripts.tasks[0].scripts[0], projectTest.scripts.task1.scripts[0])
234 |         assertEquals(task.getJavaCard().scripts.tasks[0].scripts[1], projectTest.scripts.task1.scripts[1])
235 | 
236 |         assertEquals(task.getJavaCard().scripts.tasks[1].name, projectTest.scripts.task2.name)
237 |         assertEquals(task.getJavaCard().scripts.tasks[1].scripts.size(), 2)
238 |         assertEquals(task.getJavaCard().scripts.tasks[1].scripts[0], projectTest.scripts.task2.scripts[0])
239 |         assertEquals(task.getJavaCard().scripts.tasks[1].scripts[1], projectTest.scripts.task2.scripts[1])
240 | 
241 |         assertEquals(task.getJavaCard().test.dependencies.dependencies[0], projectTest.test.dependencies[0])
242 |         assertEquals(task.getJavaCard().test.dependencies.dependencies[1], projectTest.test.dependencies[1])
243 |     }
244 | }
245 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # JavaCard Gradle plugin
  2 | 
  3 | [![Build Status](https://travis-ci.org/ph4r05/javacard-gradle-plugin.svg?branch=master)](https://travis-ci.org/ph4r05/javacard-gradle-plugin)
  4 | [![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.klinec/gradle-javacard/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.klinec/gradle-javacard)
  5 | [![Coverage Status](https://coveralls.io/repos/github/ph4r05/javacard-gradle-plugin/badge.svg?branch=master)](https://coveralls.io/github/ph4r05/javacard-gradle-plugin?branch=master)
  6 | [![Javadoc](http://javadoc-badge.appspot.com/com.klinec/gradle-javacard.svg?label=javadoc)](http://javadoc-badge.appspot.com/com.klinec/gradle-javacard)
  7 | [![License](http://img.shields.io/:license-mit-blue.svg)](LICENSE.md)
  8 | 
  9 | A Gradle plugin for building JavaCard applets.
 10 | 
 11 | This plugin is a wrapper on [ant-javacard](https://github.com/martinpaljak/ant-javacard) and [Global Platform Pro](https://github.com/martinpaljak/GlobalPlatformPro), it is inspired by [gradle-javacard](https://github.com/fidesmo/gradle-javacard)
 12 | 
 13 | This is a fork of a great work [bertrandmartel/javacard-gradle-plugin](https://github.com/bertrandmartel/javacard-gradle-plugin),
 14 | we extended the work and added some improvements. 
 15 | 
 16 | Gradle 6.4 is the minimal version supported.
 17 | 
 18 | ## Features
 19 | 
 20 | * build JavaCard applets (with the same capabilities as [ant-javacard](https://github.com/martinpaljak/ant-javacard))
 21 | * install cap files
 22 | * list applets
 23 | * write quick testing scripts used to send apdu in a configurable way
 24 | * expose `GpExec` task type that enables usage of [Global Platform Pro](https://github.com/martinpaljak/GlobalPlatformPro) tool inside Gradle
 25 | * include [jcardsim 3.0.5](https://github.com/licel/jcardsim) and [JUnit 4.12](http://junit.org/junit4/) test dependency (clear distinction between JavaCard SDK & jcardsim SDK) 
 26 | * ability to specify key for delete/install/list tasks
 27 | * possibility to add dependency between modules (exp & jar imported automatically)
 28 | 
 29 | ## Usage 
 30 | 
 31 | It may be the best to start with a simple HelloWorld project using this gradle plugin and demonstrating basic usage.
 32 | 
 33 | Clone this [https://github.com/crocs-muni/javacard-gradle-template-edu](https://github.com/crocs-muni/javacard-gradle-template-edu)
 34 | template project with `git clone --recursive`, and try:
 35 | - `./gradlew buildJavaCard`
 36 | - `./gradlew installJavaCard`
 37 | - `./gradlew test`
 38 | 
 39 | Example gradle script:
 40 | ```groovy
 41 | buildscript {
 42 |     repositories {
 43 |         jcenter()
 44 |         mavenCentral()
 45 | 
 46 |         // Repository with Globalplatform, ant-javacard, gppro, gptools, etc.
 47 |         maven { url "https://javacard.pro/maven" }
 48 |         maven { url "https://deadcode.me/mvn" }
 49 |     }
 50 |     dependencies {
 51 |         classpath 'com.klinec:gradle-javacard:1.8.0'
 52 |     }
 53 | }
 54 | 
 55 | apply plugin: 'com.klinec.gradle.javacard'
 56 | 
 57 | repositories {
 58 |     mavenCentral()
 59 |     // mavenLocal() // for local maven repository if needed
 60 | 
 61 |     // Repository with Globalplatform, ant-javacard, gppro, gptools, etc.
 62 |     maven { url  "https://dl.bintray.com/ph4r05/jcard" }
 63 |     maven { url "https://javacard.pro/maven" }
 64 |     maven { url "https://deadcode.me/mvn" }
 65 | }
 66 | 
 67 | javacard {
 68 | 
 69 |     config {
 70 |         
 71 |         cap {
 72 |             packageName 'fr.bmartel.javacard'
 73 |             version '0.1'
 74 |             aid '01:02:03:04:05:06:07:08:09'
 75 |             output 'applet.cap'
 76 |             applet {
 77 |                 className 'fr.bmartel.javacard.HelloWorld'
 78 |                 aid '01:02:03:04:05:06:07:08:09:01:02'
 79 |             }
 80 |         }
 81 |     }
 82 |           
 83 |     scripts {
 84 |         script {
 85 |             name 'select'
 86 |             apdu '00:A4:04:00:0A:01:02:03:04:05:06:07:08:09:01:00'
 87 |         }
 88 |         script {
 89 |             name 'hello'
 90 |             apdu '00:40:00:00:00'
 91 |         }
 92 |         task {
 93 |             name 'sendHello'
 94 |             scripts 'select', 'hello'
 95 |         }
 96 |     }
 97 | }
 98 | ```
 99 | 
100 | plugin is available from `jcenter()` or `mavenCentral()`
101 | 
102 | You can specify custom GPtool dependency with configuration `gptool`:
103 | 
104 | ```groovy
105 | dependencies {
106 |   gptool "com.github.martinpaljak:gppro:20.08.12"
107 |   gptool "com.github.martinpaljak:gptool:20.08.12"
108 |   gptool "com.github.martinpaljak:globalplatformpro:20.08.12"
109 | }
110 | ```
111 | 
112 | Check [this project](https://github.com/bertrandmartel/javacard-tutorial) for more usage examples
113 | 
114 | ## JavaCard SDK path
115 | 
116 | The path to JavaCard SDK can be specified through : 
117 | 
118 | * use `jc.home` properties in `local.properties` file located in your project root (in the same way as Android projects) : 
119 |   * in project root : `echo "jc.home=$PWD/oracle_javacard_sdks/jc222_kit" >> local.properties`
120 | * using `jckit` attribute (see [ant-javacard](https://github.com/martinpaljak/ant-javacard#syntax))
121 | * `JC_HOME` global environment variable, for instance using : `export JC_HOME="$PWD/sdks/jck222_kit"`
122 | 
123 | ## Tasks
124 | 
125 | | task name    | description   |
126 | |--------------|---------------|
127 | | buildJavaCard | build JavaCard cap files |
128 | | installJavaCard | delete existing aid & install all JavaCard cap files (`gp --delete XXXX --install file.cap`) |
129 | | listJavaCard | list applets (`gp -l`) |
130 | 
131 | It's possible to create custom tasks that will send series of custom apdu :
132 | 
133 | ```groovy
134 | scripts {
135 |     script {
136 |         name 'select'
137 |         apdu '00:A4:04:00:0A:01:02:03:04:05:06:07:08:09:01:00'
138 |     }
139 |     script {
140 |         name 'hello'
141 |         apdu '00:40:00:00:00'
142 |     }
143 |     task {
144 |         name 'sendHello'
145 |         scripts 'select', 'hello'
146 |     }
147 | }
148 | ```
149 | 
150 | The above will create task `sendHello` that will select applet ID `01:02:03:04:05:06:07:08:09:01` and send the apdu `00:40:00:00:00`.  
151 | The order of the scripts's apdu in `task.scripts` is respected.  
152 | `00:A4:04:00:0A:01:02:03:04:05:06:07:08:09:01:00` or `'00A404000A0102030405060708090100'` are valid apdu.
153 | 
154 | ## Custom Global Platform Pro task
155 | 
156 | You can build custom tasks that launch [Global Platform Pro](https://github.com/martinpaljak/GlobalPlatformPro) tool :
157 | 
158 | ```groovy
159 | task displayHelp(type: com.klinec.gradle.javacard.gp.GpExec) {
160 |     description = 'display Global Platform pro help'
161 |     group = 'help'
162 |     args '-h'
163 | }
164 | ```
165 | 
166 | ## More complex example
167 | 
168 | ```groovy
169 | apply plugin: 'javacard'
170 | 
171 | repositories {
172 |     maven {
173 |         url 'http://dl.bintray.com/bertrandmartel/maven'
174 |     }
175 | }
176 | 
177 | javacard {
178 | 
179 |     config {
180 |         jckit '../oracle_javacard_sdks/jc222_kit'
181 |         cap {
182 |             packageName 'fr.bmartel.javacard'
183 |             version '0.1'
184 |             aid '01:02:03:04:05:06:07:08:09'
185 |             output 'applet1.cap'
186 |             applet {
187 |                 className 'fr.bmartel.javacard.HelloSmartcard'
188 |                 aid '01:02:03:04:05:06:07:08:09:01:02'
189 |             }
190 |             applet {
191 |                 className 'fr.bmartel.javacard.GoodByeSmartCard'
192 |                 aid '01:02:03:04:05:06:07:08:09:01:03'
193 |             }
194 |         }
195 |         cap {
196 |             packageName 'fr.bmartel.javacard'
197 |             version '0.1'
198 |             aid '01:02:03:04:05:06:07:08:0A'
199 |             output 'applet2.cap'
200 |             applet {
201 |                 className 'fr.bmartel.javacard.SomeOtherClass'
202 |                 aid '01:02:03:04:05:06:07:08:09:01:04'
203 |             }
204 |             dependencies {
205 |                 local {
206 |                     jar '/path/to/dependency.jar'
207 |                     exps '/path/to/expfolder'
208 |                 }
209 |                 remote 'fr.bmartel:gplatform:2.1.1'
210 |             }
211 |         }
212 |     }
213 |     
214 |     defaultKey '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
215 |     // or 
216 |     /*
217 |     key {
218 |         enc '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
219 |         kek '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F' 
220 |         mac '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F' 
221 |     }
222 |     */
223 | 
224 |     scripts {
225 |         script {
226 |             name 'select'
227 |             apdu '00:A4:04:00:0A:01:02:03:04:05:06:07:08:09:01:00'
228 |         }
229 |         script {
230 |             name 'hello'
231 |             apdu '00:40:00:00:00'
232 |         }
233 |         task {
234 |             name 'sendHello'
235 |             scripts 'select', 'hello'
236 |         }
237 |     }
238 | }
239 | ```
240 | 
241 | Note1 : the `remote` dependency will automatically download the `jar` (the `jar` file must include the `exp` file)  
242 | Note2 : you can add as many `local` or `remote` dependency as you want
243 | 
244 | ## Syntax
245 | 
246 | * javacard [Closure]
247 |   * config [Closure] - object that holds build configuration **Required**
248 |     * jckit [String] - path to the JavaCard SDK that is used if individual cap does not specify one. Optional if cap defines one, required otherwise. The path is relative to the module
249 |     * logLevel [String] - log level of ant-javacard task ("VERBOSE","DEBUG","INFO","WARN","ERROR"). default : "INFO"
250 |     * antClassPath [String] - option to specify path to the `ant-javacard.jar`
251 |     * jcardSim [dependency] - gradle dependency specifier for the JCardSim to use
252 |     * gptoolVersion [String] - enables you to specify GPtools version that will be used (in case you do not specify custom deps for `gptool` configuration)
253 |     * addImplicitJcardSim [Boolean] - adds JCardSim dependency to the project, true by default. Recommended: false
254 |     * addImplicitJcardSimJunit [Boolean] - adds Junit dependency to the jcardsim dependency. Recommended: false and define you own junit version
255 |     * debugGpPro [Boolean] - if true, adds `-d` param to the GPPro tasks for more verbose output
256 |     * fixClassPath [Boolean] - if true, tries to fix test classpath if JC `api_classic.jar` appears before jcardsim.
257 |     * installGpProArgs [List<String>] - List of additional GPPro args to add to the installJavaCard task
258 |     * cap [Closure] - construct a CAP file **Required**
259 |       * jckit [String] - path to the JavaCard SDK to be used for this CAP. *Optional if javacard defines one, required otherwise*
260 |       * targetsdk [String] - path to the target JavaCard SDK to be used for this CAP. Optional, value of jckit used by default. Allows to use a more recent converter to target older JavaCard platforms.
261 |       * sources [String] - path to Java source code, to be compiled against the current JavaCard SDK. **Required**
262 |       * sources2 [String] - additional sources to build per-platform applets. Optional.
263 |       * findSources [boolean] - default:true, if true the sources are determined automatically. The first existing source dir in source sets is taken
264 |       * defaultSources [boolean] - default:true, if true the first source dir from the source set is used. Otherwise the most recet (last)
265 |       * classes [String] - path to pre-compiled class files to be assembled into a CAP file. If both classes and sources are specified, compiled class files will be put to classes folder, which is created if missing
266 |       * include [String] - comma or space separated list of patterns of files that must be included.
267 |       * exclude [String] - comma or space separated list of patterns of files that must be excluded.
268 |       * packageName [String] - name of the package of the CAP file. Optional - set to the parent package of the applet class if left unspecified.
269 |       * version [String] - version of the package. Optional - defaults to 0.0 if left unspecified.
270 |       * aid [String] - AID (hex) of the package. Recommended - or set to the 5 first bytes of the applet AID if left unspecified.
271 |       * output [String] - path where to save the generated CAP file. if a filename or a non-absolute path is referenced, the output will be in `build/javacard/{output}` **Required**
272 |       * export [String] - path (folder) where to place the JAR and generated EXP file. Default output directory is `build/javacard`. Filename depends on `output` filename if referenced. Optional.
273 |       * jar [String] - path where to save the generated archive JAR file. Optional.
274 |       * jca [String] - path where to save the generated JavaCard Assembly (JCA) file. Default output directory is `build/javacard`. Filename depends on `output` filename if referenced. Optional.
275 |       * verify [boolean] - if set to false, disables verification of the resulting CAP file with offcardeverifier. Optional.
276 |       * debug [boolean] - if set to true, generates debug CAP components. Optional.
277 |       * ints [boolean] - if set to true, enables support for 32 bit int type. Optional.
278 |       * javaversion [string] - override the Java source and target version. Optional.
279 |       * applet [Closure] - for creating an applet inside the CAP
280 |         * className [String] - class of the Applet where install() method is defined. **Required**
281 |         * aid [String] - AID (hex) of the applet. Recommended - or set to package aid+i where i is index of the applet definition in the build.xml instruction
282 |       * dependencies [Closure] - for linking against external components/libraries, like GPSystem or OPSystem
283 |         * local [Closure] local dependencies must include absolute path to exp/jar
284 |           * exps [String] - path to the folder keeping .exp files. Required
285 |           * jar [String] - path to the JAR file for compilation. Optional - only required if using sources mode and not necessary with classes mode if java code is already compiled
286 |         * remote [String] remote dependencies (ex: "group:module:1.0").the remote repository (maven repo) must be included in the project
287 |   * key [Closure] key configuration (if not defined the default keys will be used)
288 |     * enc [String] ENC key
289 |     * kek [String] KEK key
290 |     * mac [String] MAC key
291 |   * defaultKey [String] default key used (will be used for enc, kek and mac key if not specified in key closure)
292 |   * scripts [Closure] - object that holds the configurable scripts to send apdu
293 |      * script [Closure] - a script referenced by name/apdu value to be sent
294 |        * name [String] - script name (ex: select)
295 |        * apdu [String] - apdu value to be sent (it can hold ":" to separate bytes)
296 |      * task [Closure] - gradle task to create that will map the specified list of apdu to send
297 |        * name [String] - task name
298 |        * scripts [String...] - list of script's name
299 |   * test [Closure] - additional configuration for tests(*)
300 |      * dependencies [Closure] - holds test dependencies
301 |        * compile [String] - add a dependencies (ex: 'junit:junit:4.12')
302 | 
303 | (*) If you specify at least one dependency, jcardsim & junit won't be automatically added so you will need to add them manually if you need them for example :
304 | 
305 | ```groovy
306 | test {
307 |     dependencies {
308 |         compile 'junit:junit:4.12'
309 |         compile 'com.licel:jcardsim:3.0.4'
310 |     }
311 | }
312 | ```
313 | 
314 | ## Compatibility
315 | 
316 | This plugin has been tested on following IDE : 
317 | 
318 | * IntelliJ IDEA
319 | * Android Studio
320 | * Eclipse
321 | 
322 | Recommended IDE : IntelliJ IDEA or Android Studio
323 | 
324 | ## License
325 | 
326 | The MIT License (MIT) Copyright (c) 2017-2018 Bertrand Martel
327 | 


--------------------------------------------------------------------------------
/gradle-javacard/src/test/groovy/com/klinec/gradle/javacard/StaticConfig.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The MIT License (MIT)
  3 |  * <p/>
  4 |  * Copyright (c) 2017-2018 Bertrand Martel
  5 |  * <p/>
  6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7 |  * of this software and associated documentation files (the "Software"), to deal
  8 |  * in the Software without restriction, including without limitation the rights
  9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 |  * copies of the Software, and to permit persons to whom the Software is
 11 |  * furnished to do so, subject to the following conditions:
 12 |  * <p/>
 13 |  * The above copyright notice and this permission notice shall be included in
 14 |  * all copies or substantial portions of the Software.
 15 |  * <p/>
 16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 |  * THE SOFTWARE.
 23 |  */
 24 | 
 25 | package com.klinec.gradle.javacard
 26 | 
 27 | /**
 28 |  * Static javacard configuration used in tests.
 29 |  *
 30 |  * @author Bertrand Martel
 31 |  */
 32 | class StaticConfig {
 33 | 
 34 |     public static String SDK_PATH = StaticConfig.getSdkPath("jc305u3_kit")
 35 |     public static String JAVA_VERSION = "1.7"
 36 | 
 37 |     /*
 38 |     public static String DEPENDENCY_PATH = System.getProperty("user.dir") + "/../../../test/libs/test.jar"
 39 |     public static String EXP_PATH = System.getProperty("user.dir") + "/../../../test/libs/test.exp"
 40 |     */
 41 |     public static repositories = {
 42 |         maven {
 43 |             url 'http://dl.bintray.com/bertrandmartel/maven'
 44 |         }
 45 |     }
 46 | 
 47 |     public static String getSdkPath(folder) {
 48 |         return System.getProperty("user.dir") + "/../sdks/" + folder
 49 |     }
 50 | 
 51 |     public static Closure VALID_CONFIG = {
 52 |         config {
 53 |             jckit SDK_PATH
 54 |             cap {
 55 |                 jckit SDK_PATH
 56 |                 javaversion JAVA_VERSION
 57 |                 packageName 'fr.bmartel.javacard'
 58 |                 version '0.1'
 59 |                 aid '01:02:03:04:05:06:07:08:09'
 60 |                 output 'applet.cap'
 61 |                 applet {
 62 |                     className 'fr.bmartel.javacard.HelloWorld'
 63 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
 64 |                 }
 65 |                 dependencies {
 66 |                     remote 'fr.bmartel:gplatform:2.1.1'
 67 |                 }
 68 |             }
 69 |         }
 70 | 
 71 |         test {
 72 |             dependencies {
 73 |                 compile 'junit:junit:4.12'
 74 |                 compile 'com.licel:jcardsim:3.0.4'
 75 |             }
 76 |         }
 77 | 
 78 |         key {
 79 |             enc '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
 80 |             dek '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
 81 |             mac '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
 82 |         }
 83 |     }
 84 | 
 85 |     public static Closure VALID_CONFIG_MIXED_KEY = {
 86 |         config {
 87 |             jckit SDK_PATH
 88 |             cap {
 89 |                 jckit SDK_PATH
 90 |                 javaversion JAVA_VERSION
 91 |                 packageName 'fr.bmartel.javacard'
 92 |                 version '0.1'
 93 |                 aid '01:02:03:04:05:06:07:08:09'
 94 |                 output 'applet.cap'
 95 |                 applet {
 96 |                     className 'fr.bmartel.javacard.HelloWorld'
 97 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
 98 |                 }
 99 |                 dependencies {
100 |                     remote 'fr.bmartel:gplatform:2.1.1'
101 |                 }
102 |             }
103 |         }
104 | 
105 |         defaultKey '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
106 | 
107 |         key {
108 |             enc '41:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
109 |             dek '42:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
110 |         }
111 |     }
112 | 
113 |     public static Closure VALID_SCRIPT_CONFIG = {
114 |         config {
115 |             jckit SDK_PATH
116 |             cap {
117 |                 jckit SDK_PATH
118 |                 javaversion JAVA_VERSION
119 |                 packageName 'fr.bmartel.javacard'
120 |                 version '0.1'
121 |                 aid '01:02:03:04:05:06:07:08:09'
122 |                 output 'applet.cap'
123 |                 applet {
124 |                     className 'fr.bmartel.javacard.HelloWorld'
125 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
126 |                 }
127 |                 dependencies {
128 |                     remote 'fr.bmartel:gplatform:2.1.1'
129 |                 }
130 |             }
131 |         }
132 | 
133 |         scripts {
134 |             script {
135 |                 name 'script1'
136 |                 apdu '010203'
137 |             }
138 |             script {
139 |                 name 'script2'
140 |                 apdu '040506'
141 |             }
142 |             task {
143 |                 name 'task1'
144 |                 scripts 'script1', 'script2'
145 |             }
146 |             task {
147 |                 name 'task2'
148 |                 scripts 'script1'
149 |             }
150 |             task {
151 |                 name 'task3'
152 |                 scripts 'script2'
153 |             }
154 |         }
155 |     }
156 | 
157 |     public static Closure VALID_SCRIPT_CONFIG_DEFAULT_KEY = {
158 | 
159 |         defaultKey '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
160 | 
161 |         config {
162 |             jckit SDK_PATH
163 |             cap {
164 |                 jckit SDK_PATH
165 |                 javaversion JAVA_VERSION
166 |                 packageName 'fr.bmartel.javacard'
167 |                 version '0.1'
168 |                 aid '01:02:03:04:05:06:07:08:09'
169 |                 output 'applet.cap'
170 |                 applet {
171 |                     className 'fr.bmartel.javacard.HelloWorld'
172 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
173 |                 }
174 |                 dependencies {
175 |                     remote 'fr.bmartel:gplatform:2.1.1'
176 |                 }
177 |             }
178 |         }
179 | 
180 |         scripts {
181 |             script {
182 |                 name 'script1'
183 |                 apdu '010203'
184 |             }
185 |             script {
186 |                 name 'script2'
187 |                 apdu '040506'
188 |             }
189 |             task {
190 |                 name 'task1'
191 |                 scripts 'script1', 'script2'
192 |             }
193 |             task {
194 |                 name 'task2'
195 |                 scripts 'script1'
196 |             }
197 |             task {
198 |                 name 'task3'
199 |                 scripts 'script2'
200 |             }
201 |         }
202 |     }
203 | 
204 |     public static Closure VALID_SCRIPT_CONFIG_WITH_KEY = {
205 |         key {
206 |             enc '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
207 |             dek '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
208 |             mac '40:41:42:43:44:45:46:47:48:49:4A:4B:4C:4D:4E:4F'
209 |         }
210 |         config {
211 |             jckit SDK_PATH
212 |             cap {
213 |                 jckit SDK_PATH
214 |                 javaversion JAVA_VERSION
215 |                 packageName 'fr.bmartel.javacard'
216 |                 version '0.1'
217 |                 aid '01:02:03:04:05:06:07:08:09'
218 |                 output 'applet.cap'
219 |                 applet {
220 |                     className 'fr.bmartel.javacard.HelloWorld'
221 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
222 |                 }
223 |                 dependencies {
224 |                     remote 'fr.bmartel:gplatform:2.1.1'
225 |                 }
226 |             }
227 |         }
228 | 
229 |         scripts {
230 |             script {
231 |                 name 'script1'
232 |                 apdu '010203'
233 |             }
234 |             script {
235 |                 name 'script2'
236 |                 apdu '040506'
237 |             }
238 |             task {
239 |                 name 'task1'
240 |                 scripts 'script1', 'script2'
241 |             }
242 |             task {
243 |                 name 'task2'
244 |                 scripts 'script1'
245 |             }
246 |             task {
247 |                 name 'task3'
248 |                 scripts 'script2'
249 |             }
250 |         }
251 |     }
252 | 
253 |     public static Closure RUNNABLE_SCRIPT_CONFIG = {
254 |         config {
255 |             jckit SDK_PATH
256 |             cap {
257 |                 jckit SDK_PATH
258 |                 javaversion JAVA_VERSION
259 |                 packageName 'fr.bmartel.javacard'
260 |                 version '0.1'
261 |                 aid '01:02:03:04:05:06:07:08:09'
262 |                 output 'applet.cap'
263 |                 applet {
264 |                     className 'fr.bmartel.javacard.HelloWorld'
265 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
266 |                 }
267 |                 dependencies {
268 |                     remote 'fr.bmartel:gplatform:2.1.1'
269 |                 }
270 |             }
271 |         }
272 | 
273 |         scripts {
274 |             script {
275 |                 name 'select'
276 |                 apdu '00:A4:04:00:0A:01:02:03:04:05:06:07:08:09:01:00'
277 |             }
278 |             script {
279 |                 name 'hello'
280 |                 apdu '00:40:00:00:00'
281 |             }
282 |             task {
283 |                 name 'task1'
284 |                 scripts 'select', 'hello'
285 |             }
286 |         }
287 |     }
288 | 
289 |     public static Closure SIMPLE_CONFIG = {
290 |         config {
291 |             jckit SDK_PATH
292 |             cap {
293 |                 jckit SDK_PATH
294 |                 javaversion JAVA_VERSION
295 |                 packageName 'fr.bmartel.javacard'
296 |                 version '0.1'
297 |                 aid '01:02:03:04:05:06:07:08:09'
298 |                 output 'applet.cap'
299 |                 applet {
300 |                     className 'fr.bmartel.javacard.HelloWorld'
301 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
302 |                 }
303 |             }
304 |         }
305 |     }
306 | 
307 |     public static Closure FULL_OUTPUT = {
308 |         config {
309 |             jckit SDK_PATH
310 |             cap {
311 |                 jckit SDK_PATH
312 |                 javaversion JAVA_VERSION
313 |                 packageName 'fr.bmartel.javacard'
314 |                 version '0.1'
315 |                 aid '01:02:03:04:05:06:07:08:09'
316 |                 output 'applet.cap'
317 |                 export 'other.exp'
318 |                 jca 'someother.jca'
319 |                 applet {
320 |                     className 'fr.bmartel.javacard.HelloWorld'
321 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
322 |                 }
323 |                 dependencies {
324 |                 }
325 |             }
326 |         }
327 |     }
328 | 
329 |     public static Closure MULTIPLE_APPLETS = {
330 |         config {
331 |             cap {
332 |                 jckit SDK_PATH
333 |                 javaversion JAVA_VERSION
334 |                 packageName 'fr.bmartel.javacard'
335 |                 version '0.1'
336 |                 aid '01:02:03:04:05:06:07:08:09'
337 |                 output 'applet.cap'
338 |                 applet {
339 |                     className 'fr.bmartel.javacard.HelloWorld'
340 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
341 |                 }
342 |                 applet {
343 |                     className 'fr.bmartel.javacard.HelloWorld2'
344 |                     aid '01:02:03:04:05:06:07:08:09:01:03'
345 |                 }
346 |                 dependencies {
347 |                 }
348 |             }
349 |         }
350 |     }
351 | 
352 |     public static Closure MULTIPLE_CAPS = {
353 |         config {
354 |             cap {
355 |                 jckit SDK_PATH
356 |                 javaversion JAVA_VERSION
357 |                 packageName 'fr.bmartel.javacard'
358 |                 version '0.1'
359 |                 aid '01:02:03:04:05:06:07:08:09'
360 |                 output 'applet.cap'
361 |                 applet {
362 |                     className 'fr.bmartel.javacard.HelloWorld'
363 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
364 |                 }
365 |                 dependencies {
366 |                 }
367 |             }
368 |             cap {
369 |                 jckit SDK_PATH
370 |                 javaversion JAVA_VERSION
371 |                 packageName 'fr.bmartel.javacard'
372 |                 version '0.1'
373 |                 aid '01:02:03:04:05:06:07:08:09'
374 |                 output 'applet2.cap'
375 |                 applet {
376 |                     className 'fr.bmartel.javacard.HelloWorld'
377 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
378 |                 }
379 |                 dependencies {
380 |                 }
381 |             }
382 |         }
383 |     }
384 | 
385 |     public static Closure UNDEFINED_JCKIT_PATH = {
386 |         config {
387 |             cap {
388 |                 packageName 'fr.bmartel.javacard'
389 |                 version '0.1'
390 |                 aid '01:02:03:04:05:06:07:08:09'
391 |                 output 'applet.cap'
392 |                 applet {
393 |                     className 'fr.bmartel.javacard.HelloWorld'
394 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
395 |                 }
396 |                 dependencies {
397 |                 }
398 |             }
399 |         }
400 |     }
401 | 
402 |     public static Closure INVALID_JCKIT_PATH = {
403 |         config {
404 |             cap {
405 |                 jckit 'path/to'
406 |                 packageName 'fr.bmartel.javacard'
407 |                 version '0.1'
408 |                 aid '01:02:03:04:05:06:07:08:09'
409 |                 output 'applet.cap'
410 |                 applet {
411 |                     className 'fr.bmartel.javacard.HelloWorld'
412 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
413 |                 }
414 |                 dependencies {
415 |                 }
416 |             }
417 |         }
418 |     }
419 | 
420 |     public static Closure OUTPUT_REQUIRED = {
421 |         config {
422 |             cap {
423 |                 jckit SDK_PATH
424 |                 javaversion JAVA_VERSION
425 |                 packageName 'fr.bmartel.javacard'
426 |                 version '0.1'
427 |                 aid '01:02:03:04:05:06:07:08:09'
428 |                 applet {
429 |                     className 'fr.bmartel.javacard.HelloWorld'
430 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
431 |                 }
432 |                 dependencies {
433 |                 }
434 |             }
435 |         }
436 |     }
437 | 
438 |     public static Closure APPLET_CLASSNAME_REQUIRED = {
439 |         config {
440 |             cap {
441 |                 jckit SDK_PATH
442 |                 javaversion JAVA_VERSION
443 |                 packageName 'fr.bmartel.javacard'
444 |                 version '0.1'
445 |                 aid '01:02:03:04:05:06:07:08:09'
446 |                 applet {
447 |                     aid '01:02:03:04:05:06:07:08:09:01:02'
448 |                 }
449 |                 dependencies {
450 |                 }
451 |             }
452 |         }
453 |     }
454 | 
455 |     public static Closure MISSING_ALL_CAPS = {
456 |         config {
457 |             cap {
458 | 
459 |             }
460 |         }
461 |     }
462 | 
463 |     public static Closure NO_FIELDS = {
464 |         config {
465 | 
466 |         }
467 |     }
468 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/JavaCardBuildTask.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The MIT License (MIT)
  3 |  * <p/>
  4 |  * Copyright (c) 2017-2018 Bertrand Martel
  5 |  * <p/>
  6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7 |  * of this software and associated documentation files (the "Software"), to deal
  8 |  * in the Software without restriction, including without limitation the rights
  9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 |  * copies of the Software, and to permit persons to whom the Software is
 11 |  * furnished to do so, subject to the following conditions:
 12 |  * <p/>
 13 |  * The above copyright notice and this permission notice shall be included in
 14 |  * all copies or substantial portions of the Software.
 15 |  * <p/>
 16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 |  * THE SOFTWARE.
 23 |  */
 24 | 
 25 | package com.klinec.gradle.javacard
 26 | 
 27 | 
 28 | import com.sun.media.sound.InvalidDataException
 29 | import com.klinec.gradle.javacard.extension.JavaCard
 30 | import com.klinec.gradle.javacard.util.Utility
 31 | import groovy.io.FileType
 32 | import org.gradle.api.DefaultTask
 33 | import org.gradle.api.InvalidUserDataException
 34 | import org.gradle.api.artifacts.ProjectDependency
 35 | import org.gradle.api.tasks.Input
 36 | import org.gradle.api.tasks.Internal
 37 | import org.gradle.api.tasks.Optional
 38 | import org.gradle.api.tasks.TaskAction
 39 | import org.slf4j.Logger
 40 | import org.slf4j.LoggerFactory
 41 | 
 42 | /**
 43 |  * JavaCard task running the ant-javacard task from Martin Paljak
 44 |  *
 45 |  * @author Bertrand Martel
 46 |  */
 47 | class JavaCardBuildTask extends DefaultTask {
 48 | 
 49 |     /**
 50 |      * default directory for output
 51 |      */
 52 |     @Optional
 53 |     @Input
 54 |     def jcBuildDir = project.buildDir.absolutePath + File.separator + "javacard"
 55 | 
 56 |     @TaskAction
 57 |     def build() {
 58 |         ant.lifecycleLogLevel = project.javacard.config.logLevel
 59 | 
 60 |         //get location of ant-javacard task jar
 61 |         def loc = project.javacard.config.antClassPath
 62 |         if (loc == null || loc.trim() == "") {
 63 |             def tloc = new File(pro.javacard.ant.JavaCard.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath())
 64 |             def tloc2 = new File(pro.javacard.VerifierError.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath())
 65 |             loc = tloc.absolutePath + File.pathSeparator + tloc2.absolutePath
 66 |             logger.info("javacard task location auto-detected : ${loc}")
 67 |         }
 68 | 
 69 |         logger.info("javacard task location : ${loc}")
 70 | 
 71 |         ant.taskdef(name: 'javacard',
 72 |                 classname: 'pro.javacard.ant.JavaCard',
 73 |                 classpath: loc)
 74 | 
 75 |         ant.javacard(buildJavacardMap(project.javacard.config.jckit)) {
 76 | 
 77 |             project.javacard.config.caps.each() { capItem ->
 78 | 
 79 |                 updateOutputFilePath(capItem)
 80 | 
 81 |                 cap(buildCapMap(capItem)) {
 82 |                     capItem.applets.each() { appletItem ->
 83 |                         applet(buildAppletMap(appletItem))
 84 |                     }
 85 | 
 86 |                     // for each dependent project add an import with exp folder & jar
 87 |                     getAllDependentProjects(project).each {
 88 |                         def expFolder = ""
 89 |                         def jarPath = ""
 90 | 
 91 |                         new File(it.ext.javacardDir).eachFile() {
 92 |                             if (it.isDirectory()) {
 93 |                                 expFolder = it.absolutePath
 94 |                                 it.eachFileMatch(FileType.ANY, ~/.*\.jar/) {
 95 |                                     jarPath = it.absolutePath
 96 |                                 }
 97 |                             }
 98 |                         }
 99 | 
100 |                         logger.info("import attributes : " + [
101 |                                 exps: expFolder,
102 |                                 jar : jarPath
103 |                         ])
104 | 
105 |                         "import"([
106 |                                 exps: expFolder,
107 |                                 jar : jarPath
108 |                         ])
109 |                     }
110 | 
111 |                     if (capItem.dependencies != null) {
112 |                         capItem.dependencies.local.each() { localItem ->
113 |                             "import"(buildLocalItem(localItem))
114 |                         }
115 | 
116 |                         capItem.dependencies.remote.each() { remoteItem ->
117 |                             "import"(buildRemoteItem(remoteItem))
118 |                         }
119 |                     }
120 |                 }
121 |             }
122 |         }
123 |     }
124 | 
125 |     /**
126 |      * build cap attribute map
127 |      *
128 |      * @param capItem cap item
129 |      * @return map of cap attributes
130 |      */
131 |     def buildCapMap(capItem) {
132 |         def map = [:]
133 |         if (capItem.jckit?.trim()) {
134 |             map["jckit"] = capItem.jckit
135 |         }
136 |         if (capItem.targetsdk?.trim()) {
137 |             map["targetsdk"] = capItem.targetsdk
138 |         }
139 |         if (capItem.sources?.trim()) {
140 |             map["sources"] = capItem.sources
141 |         }
142 |         if (capItem.sources2?.trim()) {
143 |             map["sources2"] = capItem.sources2
144 |         }
145 |         if (capItem.classes?.trim()) {
146 |             map["classes"] = capItem.classes
147 |         }
148 |         if (capItem.include?.trim()) {
149 |             map["include"] = capItem.include
150 |         }
151 |         if (capItem.exclude?.trim()) {
152 |             map["exclude"] = capItem.exclude
153 |         }
154 |         if (capItem.packageName?.trim()) {
155 |             map["package"] = capItem.packageName
156 |         }
157 |         if (capItem.version?.trim()) {
158 |             map["version"] = capItem.version
159 |         }
160 |         if (capItem.aid?.trim()) {
161 |             map["aid"] = capItem.aid
162 |         }
163 |         if (capItem.output?.trim()) {
164 |             map["output"] = capItem.output
165 |         }
166 |         if (capItem.export?.trim()) {
167 |             map["export"] = capItem.export
168 |         }
169 |         if (capItem.jar?.trim()) {
170 |             map["jar"] = capItem.jar
171 |         }
172 |         if (capItem.jca?.trim()) {
173 |             map["jca"] = capItem.jca
174 |         }
175 |         if (capItem.javaversion?.trim()) {
176 |             map["javaversion"] = capItem.javaversion
177 |         }
178 |         map["verify"] = capItem.verify
179 |         map["ints"] = capItem.ints
180 |         map["debug"] = capItem.debug
181 |         logger.info("cap attributes : $map")
182 |         return map
183 |     }
184 | 
185 |     /**
186 |      * build javacard attribute map.
187 |      *
188 |      * @param jckit jckit
189 |      * @return map of javacard attributes
190 |      */
191 |     def buildJavacardMap(jckit) {
192 |         def map = [:]
193 |         if (jckit?.trim()) {
194 |             map["jckit"] = jckit
195 |         }
196 |         logger.info("javacard attributes : $map")
197 |         return map
198 |     }
199 | 
200 |     /**
201 |      * Build applet attribute map.
202 |      *
203 |      * @param appletItem applet item
204 |      * @return map of applet attributes
205 |      */
206 |     def buildAppletMap(appletItem) {
207 |         def map = [:]
208 |         if (appletItem.className?.trim()) {
209 |             map["class"] = appletItem.className
210 |         }
211 |         if (appletItem.aid?.trim()) {
212 |             map["aid"] = appletItem.aid
213 |         }
214 |         logger.info("applet attributes : $map")
215 |         return map
216 |     }
217 | 
218 |     /**
219 |      * Get all dependent project : https://discuss.gradle.org/t/getting-all-project-dependencies/6540/2 by Ahsan_Rabbani
220 |      *
221 |      * @param project
222 |      * @return
223 |      */
224 |     def getAllDependentProjects(project, configToUse=null) {
225 |         def configArr = []
226 |         if (configToUse != null) {
227 |             configArr.add(new Tuple(configToUse, project.configurations.findByName(configToUse)))
228 |         }
229 |         else {
230 |             def configImpl = new Tuple("implementation", project.configurations.findByName("implementation"))
231 |             def configCompile = new Tuple("compile", project.configurations.findByName("compile"))
232 |             def configRuntime = new Tuple("runtime", project.configurations.findByName("runtime"))
233 |             configArr = [configImpl, configCompile, configRuntime]
234 |         }
235 | 
236 |         for (config in configArr) {
237 |             if (config[1] == null){
238 |                 continue
239 |             }
240 | 
241 |             def projectDependencies = config[1].getAllDependencies().withType(ProjectDependency)
242 |             logger.debug("DependentProjects configuration: ${config[0]}:${config[1]}, projectDependencies: ${projectDependencies}")
243 | 
244 |             def dependentProjects = projectDependencies*.dependencyProject
245 |             if (dependentProjects.size > 0) {
246 |                 dependentProjects.each { dependentProjects += getAllDependentProjects(it, config[0]) }
247 |             }
248 |             return dependentProjects.unique()
249 |         }
250 |     }
251 | 
252 |     /**
253 |      * Build import attributes map for local item.
254 |      *
255 |      * @param Import import item
256 |      * @return map of import attributes
257 |      */
258 |     def buildLocalItem(importItem) {
259 |         def map = [:]
260 |         if (importItem.exps?.trim()) {
261 |             map["exps"] = importItem.exps
262 |         }
263 |         if (importItem.jar?.trim()) {
264 |             map["jar"] = importItem.jar
265 |         }
266 |         logger.info("import attributes : $map")
267 |         return map
268 |     }
269 | 
270 |     /**
271 |      * Build import attributes map for remote item.
272 |      *
273 |      * @param String remote item
274 |      * @return map of import attributes
275 |      */
276 |     def buildRemoteItem(remote) {
277 |         def map = [:]
278 |         if (remote?.trim()) {
279 |             def confName = remote.replaceAll("[^a-zA-Z0-9_.-]", "-")
280 |             logger.debug("Remote dependency configuration: ${confName} remote: ${remote}")
281 | 
282 |             project.configurations.create(confName)
283 |             project.dependencies.add(confName, remote)
284 | 
285 |             def jarConf = project.configurations[confName].resolve()
286 | 
287 |             if (jarConf.size() > 0) {
288 |                 Utility.unzip(jarConf[0].getAbsolutePath(), jarConf[0].getParent())
289 |                 map["exps"] = jarConf[0].getParent()
290 |                 map["jar"] = jarConf[0].getAbsolutePath()
291 |             } else {
292 |                 logger.error("error : exp/jar wasn't found in remote dependency : $remote")
293 |                 throw new InvalidDataException()
294 |             }
295 |         }
296 |         logger.info("import attributes : $map")
297 |         return map
298 |     }
299 | 
300 |     /**
301 |      * Finds first available source set match
302 |      * @param capItem
303 |      * @return
304 |      */
305 |     def findDefaultSources(capItem) {
306 |         if (capItem.findSources) {
307 |             def folderFound = false
308 |             def folderIdx = 0
309 |             for (curSrcDir in project.sourceSets.main.java.srcDirs) {
310 |                 if (curSrcDir.exists() && (capItem.defaultSources || folderIdx > 0)) {
311 |                     folderFound = true
312 |                     capItem.sources = curSrcDir
313 |                     break
314 |                 }
315 |                 folderIdx += 1
316 |             }
317 | 
318 |             if (!folderFound) {
319 |                 throw new InvalidUserDataException("Applet sources not found : ${project.sourceSets.main.java.srcDirs[0]}")
320 |             }
321 | 
322 |         } else {
323 |             def srcIndex = capItem.defaultSources ? 0 : project.sourceSets.main.java.srcDirs.size() - 1
324 |             capItem.sources = project.sourceSets.main.java.srcDirs[srcIndex]
325 |         }
326 | 
327 |         logger.info("update source path to ${capItem.sources}")
328 |     }
329 | 
330 |     /**
331 |      * Update output file path inclusing cap, exp and jca
332 |      *
333 |      * @param capItem cap object
334 |      */
335 |     def updateOutputFilePath(capItem) {
336 |         if (!capItem.sources?.trim()) {
337 |             findDefaultSources(capItem)
338 |         }
339 | 
340 |         File file = new File(capItem.output)
341 |         if (!file.isAbsolute()) {
342 |             Utility.createFolder(jcBuildDir)
343 |             if (!capItem.jca?.trim()) {
344 |                 capItem.jca = "${jcBuildDir}${File.separator}${Utility.removeExtension(capItem.output)}.jca"
345 |                 logger.info("update jca path to $capItem.jca")
346 |             }
347 |             if (!capItem.export?.trim()) {
348 |                 capItem.export = "${jcBuildDir}${File.separator}${Utility.removeExtension(capItem.output)}.exp"
349 |                 logger.info("update export path to $capItem.export")
350 |             }
351 |             if (!capItem.jar?.trim()) {
352 |                 capItem.jar = "${capItem.export}/${capItem.packageName ?: Utility.removeExtension(capItem.output)}.jar"
353 |                 logger.info("update jar path to $capItem.jar")
354 |             }
355 |             capItem.output = "${jcBuildDir}${File.separator}${capItem.output}"
356 |         } else {
357 |             if (!capItem.jca?.trim()) {
358 |                 capItem.jca = "${jcBuildDir}${File.separator}${Utility.removeExtension(capItem.output)}.jca"
359 |                 logger.info("update jca path to $capItem.jca")
360 |                 Utility.createFolder(jcBuildDir)
361 |             }
362 |             if (!capItem.export?.trim()) {
363 |                 capItem.export = "${jcBuildDir}${File.separator}${Utility.removeExtension(capItem.output)}.exp"
364 |                 logger.info("update export path to $capItem.export")
365 |                 Utility.createFolder(jcBuildDir)
366 |             }
367 |             if (!capItem.jar?.trim()) {
368 |                 capItem.jar = "${capItem.export}/${capItem.packageName ?: Utility.removeExtension(capItem.output)}.jar"
369 |                 logger.info("update jar path to $capItem.jar")
370 |                 Utility.createFolder(jcBuildDir)
371 |             }
372 |         }
373 | 
374 |         //update jca & export when non absolute path are referenced
375 |         File jcaFile = capItem.jca ? new File(capItem.jca) : null
376 |         if (!jcaFile?.isAbsolute()) {
377 |             capItem.jca = "${jcBuildDir}${File.separator}${capItem.jca}"
378 |             logger.info("update jca path to $capItem.jca")
379 |         }
380 |         File exportFile = capItem.export ? new File(capItem.export) : null
381 |         if (!exportFile?.isAbsolute()) {
382 |             capItem.export = "${jcBuildDir}${File.separator}${capItem.export}"
383 |             logger.info("update export path to $capItem.export")
384 |         }
385 |         File jarFile = capItem.jar ? new File(capItem.jar) : null
386 |         if (!jarFile?.isAbsolute()) {
387 |             capItem.jar = "${jcBuildDir}${File.separator}${capItem.jar}"
388 |             logger.info("update jar path to $capItem.jar")
389 |         }
390 |     }
391 | 
392 |     /**
393 |      * Get JavaCard project object
394 |      * @return
395 |      */
396 |     @Internal
397 |     JavaCard getJavaCard() {
398 |         return project.javacard
399 |     }
400 | }


--------------------------------------------------------------------------------
/gradle-javacard/src/main/groovy/com/klinec/gradle/javacard/JavaCardPlugin.groovy:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * The MIT License (MIT)
  3 |  * <p/>
  4 |  * Copyright (c) 2017-2018 Bertrand Martel
  5 |  * <p/>
  6 |  * Permission is hereby granted, free of charge, to any person obtaining a copy
  7 |  * of this software and associated documentation files (the "Software"), to deal
  8 |  * in the Software without restriction, including without limitation the rights
  9 |  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 |  * copies of the Software, and to permit persons to whom the Software is
 11 |  * furnished to do so, subject to the following conditions:
 12 |  * <p/>
 13 |  * The above copyright notice and this permission notice shall be included in
 14 |  * all copies or substantial portions of the Software.
 15 |  * <p/>
 16 |  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 |  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 |  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 |  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 |  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 |  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 22 |  * THE SOFTWARE.
 23 |  */
 24 | 
 25 | package com.klinec.gradle.javacard
 26 | 
 27 | import com.klinec.gradle.javacard.extension.Applet
 28 | import com.klinec.gradle.javacard.extension.JavaCard
 29 | import com.klinec.gradle.javacard.gp.GpExec
 30 | import com.klinec.gradle.javacard.util.SdkUtils
 31 | import com.klinec.gradle.javacard.util.Utility
 32 | import org.gradle.api.DefaultTask
 33 | import org.gradle.api.Plugin
 34 | import org.gradle.api.Project
 35 | import org.gradle.api.Task
 36 | import org.gradle.api.plugins.JavaPlugin
 37 | import org.slf4j.Logger
 38 | import org.slf4j.LoggerFactory
 39 | import pro.javacard.gp.GPTool
 40 | 
 41 | /**
 42 |  * JavaCard plugin.
 43 |  *
 44 |  * @author Bertrand Martel
 45 |  */
 46 | class JavaCardPlugin implements Plugin<Project> {
 47 | 
 48 |     Logger logger = LoggerFactory.getLogger('javacard-logger')
 49 | 
 50 |     static String PLUGIN_NAME = 'javacard'
 51 | 
 52 |     static String LIST_TASK = 'listJavaCard'
 53 |     static String INSTALL_TASK = 'installJavaCard'
 54 |     static String BUILD_TASK = 'buildJavaCard'
 55 |     static String DELETE_TASK = 'deleteJavaCard'
 56 |     static String PRE_CARD_TASK = 'preJavaCard'
 57 | 
 58 |     static String GLOBAL_PLATFORM_GROUP = 'global platform'
 59 |     static String GLOBAL_PLATFORM_HELPER_GROUP = 'global platform helpers'
 60 | 
 61 |     Task buildTask
 62 | 
 63 |     void apply(Project project) {
 64 | 
 65 |         //define plugin extension
 66 |         def extension = project.extensions.create(PLUGIN_NAME, JavaCard)
 67 | 
 68 |         project.configurations {
 69 |             jcardsim
 70 |             sctest
 71 |             sdk
 72 |             gptool
 73 |         }
 74 | 
 75 |         project.afterEvaluate {
 76 | 
 77 |             //validate the extension properties
 78 |             extension.validate(project)
 79 | 
 80 |             File propertyFile = project.rootProject.file('local.properties')
 81 | 
 82 |             Properties properties = new Properties()
 83 |             if (propertyFile.exists()) {
 84 |                 properties.load(propertyFile.newDataInputStream())
 85 |                 if (properties.getProperty('jc.home')?.trim()) {
 86 |                     extension.config.jckit = properties.getProperty('jc.home')
 87 |                 }
 88 |             }
 89 | 
 90 |             if (!extension.config.jcardSim) {
 91 |                 extension.config.jcardSim = getJcardSim(properties)
 92 |             }
 93 | 
 94 |             if (!extension.config.gptoolVersion) {
 95 |                 extension.config.gptoolVersion = getGpToolVersion(properties)
 96 |             }
 97 | 
 98 |             logger.info("jckit location : ${extension.config.getJcKit()}")
 99 |             logger.info("jcardsim: ${extension.config.getJcardSim()}")
100 |             logger.info("gptool version: ${extension.config.getGptoolVersion()}")
101 | 
102 |             configureClasspath(project, extension)
103 | 
104 |             if (extension.scripts != null) {
105 | 
106 |                 extension.scripts.tasks.each { taskItem ->
107 | 
108 |                     def command = []
109 |                     if (extension.config.isDebugGpPro()) {
110 |                         command.add('-d')
111 |                     }
112 | 
113 |                     taskItem.scripts.each { taskIncludedScript ->
114 |                         extension.scripts.scripts.each { scriptItem ->
115 |                             if (scriptItem.name == taskIncludedScript) {
116 |                                 command.add('-a')
117 |                                 command.add(Utility.formatByteArray(scriptItem.apdu))
118 |                             }
119 |                         }
120 |                     }
121 | 
122 |                     if (!project.tasks.findByName(taskItem.name)) {
123 |                         createScriptTask(project, taskItem.name, command)
124 |                     }
125 |                 }
126 |             }
127 | 
128 |             if (!project.tasks.findByName(LIST_TASK)) {
129 |                 createListTask(project, extension)
130 |             }
131 | 
132 |             if (!project.tasks.findByName(INSTALL_TASK)) {
133 |                 createInstallTask(project, extension)
134 |             }
135 |         }
136 | 
137 |         //apply the java plugin if not defined
138 |         if (!project.plugins.hasPlugin(JavaPlugin)) {
139 |             project.plugins.apply(JavaPlugin)
140 |         }
141 | 
142 |         buildTask = project.tasks.create(BUILD_TASK, JavaCardBuildTask)
143 | 
144 |         buildTask.configure {
145 |             group = 'build'
146 |             description = 'Create CAP file(s) for installation on a smart card'
147 |         }
148 | 
149 |         //add property : javacard output directory
150 |         project.ext.javacardDir = "${project.buildDir.absolutePath}${File.separator}javacard"
151 |     }
152 | 
153 |     static def getDefaultJcardSim() {
154 |         return 'com.klinec:jcardsim:3.0.5.11'
155 |     }
156 | 
157 |     static def getDefaultJunit() {
158 |         return 'junit:junit:4.12'
159 |     }
160 | 
161 |     static def hasDependencies(JavaCard extension) {
162 |         if (extension.test != null &&
163 |                 extension.test.dependencies != null &&
164 |                 extension.test.dependencies.dependencies.size() > 0) {
165 |             return true
166 |         }
167 |         return false
168 |     }
169 | 
170 |     /**
171 |      * Tries to determine jcardsim version to use
172 |      * @param properties
173 |      * @return
174 |      */
175 |     def getJcardSim(properties){
176 |         if (System.env['JCARDSIM_VER']?.trim()) {
177 |             return System.env['JCARDSIM_VER']
178 |         }
179 | 
180 |         if (properties.getProperty('jcardsim.ver')?.trim()) {
181 |             return properties.getProperty('jcardsim.ver')
182 |         }
183 | 
184 |         if (System.getProperty("jcardsim.ver")?.trim()){
185 |             return System.getProperty("jcardsim.ver")
186 |         }
187 | 
188 |         return 'com.klinec:jcardsim:3.0.5.11'
189 |     }
190 | 
191 |     def getGpToolVersion(properties){
192 |         if (properties.getProperty('gptool.ver')?.trim()) {
193 |             return properties.getProperty('gptool.ver')
194 |         }
195 | 
196 |         if (System.getProperty("gptool.ver")?.trim()){
197 |             return System.getProperty("gptool.ver")
198 |         }
199 | 
200 |         return '20.08.12'
201 |     }
202 | 
203 |     /**
204 |      * Configure source set / dependency class path for main, tests and smartcard test
205 |      *
206 |      * @param project gradle project
207 |      * @param sdk JC SDK path
208 |      * @return
209 |      */
210 |     def configureClasspath(Project project, JavaCard extension) {
211 |         if (extension.config.addSurrogateJcardSimRepo) {
212 |             logger.warn("addSurrogateJcardSimRepo option is deprecated and has no effect")
213 |         }
214 | 
215 |         project.configurations.gptool.defaultDependencies {
216 |             it.add(project.dependencies.create("com.github.martinpaljak:gppro:${extension.config.getGptoolVersion()}"))
217 |             it.add(project.dependencies.create("com.github.martinpaljak:gptool:${extension.config.getGptoolVersion()}"))
218 |             it.add(project.dependencies.create("com.github.martinpaljak:globalplatformpro:${extension.config.getGptoolVersion()}"))
219 |         }
220 | 
221 |         project.configurations.jcardsim.defaultDependencies {
222 |             it.add(project.dependencies.create(extension.config.getJcardSim()))
223 |         }
224 | 
225 |         def testClasspath = project.configurations.jcardsim + project.files(new File(GPTool.class.getProtectionDomain().getCodeSource().getLocation().toURI().getPath()))
226 | 
227 |         def sdkPath = project.files(SdkUtils.getApiPath(extension.config.getJcKit(), logger))
228 |         project.sourceSets {
229 |             test {
230 |                 compileClasspath.from(testClasspath)
231 |                 runtimeClasspath.from(testClasspath)
232 |             }
233 |         }
234 | 
235 |         extension.config.caps.each { capItem ->
236 |             if (capItem.dependencies != null) {
237 |                 capItem.dependencies.local.each { localItem ->
238 |                     project.dependencies.add("implementation", project.files(localItem.jar))
239 |                 }
240 |                 capItem.dependencies.remote.each { remoteItem ->
241 |                     project.dependencies.add("implementation", remoteItem)
242 |                 }
243 |             }
244 |         }
245 | 
246 |         //resolve the javacard framework according to SDK version
247 |         project.dependencies {
248 |             sdk sdkPath
249 |             if (hasDependencies(extension)) {
250 |                 extension.test.dependencies.dependencies.each() { dep ->
251 |                     jcardsim dep
252 |                 }
253 | 
254 |                 if (extension.config.addImplicitJcardSimJunit){
255 |                     logger.info("addImplicitJcardSimJunit is overridden by test dependencies configuration")
256 |                 }
257 |                 if (extension.config.addImplicitJcardSim){
258 |                     logger.info("addImplicitJcardSim is overridden by test dependencies configuration")
259 |                 }
260 | 
261 |             } else {
262 |                 if (!extension.config.addImplicitJcardSimJunit) {
263 |                     logger.info("addImplicitJcardSimJunit disabled junit inclusion");
264 |                 } else {
265 |                     jcardsim getDefaultJunit()
266 |                 }
267 | 
268 |                 if (!extension.config.addImplicitJcardSim) {
269 |                     logger.info("addImplicitJcardSim disabled jcardsim inclusion")
270 |                 } else {
271 |                     jcardsim extension.config.getJcardSim()
272 |                 }
273 |             }
274 | 
275 |             testImplementation testClasspath
276 | 
277 |             // CompileOnly is required otherwise it gets added to the tests as well
278 |             // where it clashes with the JCardSim
279 |             compileOnly sdkPath
280 |         }
281 | 
282 |         // Remove JC API for test runtime classpath as JCardSim embeds own version and we need to have it first
283 |         logger.info("SDK path: ${sdkPath.getAsPath()}")
284 |         project.sourceSets.test.runtimeClasspath = project.sourceSets.test.runtimeClasspath.filter {
285 |             (it.path != sdkPath.getAsPath()) }
286 | 
287 |         // Removal of the JC API from the test.compileClasspath
288 |         if (extension.config.fixClassPath) {
289 |             // project.sourceSets.test.compileClasspath is of type org.gradle.api.internal.file.collections.DefaultConfigurableFileCollection
290 |             // type can be infered by `.getClass()`
291 |             def gfrom = project.sourceSets.test.compileClasspath.getFrom()
292 |             logger.debug("Classpath getFrom() is: ${gfrom.getClass()}")
293 |             logger.debug("Classpath getFrom() contents: ${gfrom.join(':')}")
294 | 
295 |             // This class path fix breaks modules dependencies as the list looses meta information
296 |             // about dependencies. In future release inspect how to reorder DefaultConfiguration
297 |             // and move JC API to the end of the list.
298 |             // Or: add JC API to the classpath as the last element here (omit compileOnly sdkPath)
299 |             def compileTestCp = new ArrayList<File>(project.sourceSets.test.compileClasspath.getFiles().asList())
300 |             def idxSdk = compileTestCp.findIndexOf { it.path == sdkPath.getAsPath() }
301 |             def idxSim = compileTestCp.findIndexOf { it.path.contains("jcardsim") }
302 |             if (idxSdk >= 0 && idxSim >= 0 && idxSim > idxSdk) {
303 |                 logger.debug("Test compile classpath indices: sdk: ${idxSdk} jcardsim: ${idxSim}, cp: ${compileTestCp.join(':')}")
304 |                 compileTestCp.remove(idxSdk)
305 |                 compileTestCp.add(idxSim, sdkPath)
306 | 
307 |                 logger.debug("Test compile classpath pre: ${compileTestCp}")
308 |                 project.sourceSets.test.compileClasspath = project.files(compileTestCp)
309 |                 logger.debug("Test compile classpath post: ${project.sourceSets.test.compileClasspath.join(':')}")
310 |                 logger.warn("ClassPath fix active, tests.compileClassPath was modified, information about project dependencies are lost. " +
311 |                         "Thus IDEs such as Idea can have problems importing the project with module dependencies. " +
312 |                         "To disable the classpath fix define javacard.config.fixClassPath false. ")
313 |             }
314 |         }
315 | 
316 |         logger.debug("Main compile classpath: ${project.sourceSets.main.compileClasspath.join(':')}")
317 |         logger.debug("Main runtime classpath: ${project.sourceSets.main.runtimeClasspath.join(':')}")
318 |         logger.debug("Test compile classpath: ${project.sourceSets.test.compileClasspath.join(':')}")
319 |         logger.debug("Test runtime classpath: ${project.sourceSets.test.runtimeClasspath.join(':')}")
320 | 
321 |         project.test.testLogging {
322 |             events "passed", "skipped", "failed"
323 |         }
324 | 
325 | 
326 |     }
327 | 
328 |     /**
329 |      * create GpExec install cap file task
330 |      *
331 |      * @param project gradle project
332 |      * @param extension gradle extension
333 |      * @return
334 |      */
335 |     def createInstallTask(Project project, JavaCard extension) {
336 |         def args = []
337 |         def delTasks = []
338 | 
339 |         def preCardTask = project.tasks.create(name: PRE_CARD_TASK, type: DefaultTask)
340 |         createTask(preCardTask, GLOBAL_PLATFORM_HELPER_GROUP, "Empty task called before card manipulation (for hooks)")
341 | 
342 |         extension.config.caps.eachWithIndex { capItem, capIdx ->
343 |             File file = new File(capItem.output)
344 |             String file2Add
345 |             if (!file.isAbsolute()) {
346 |                 file2Add = new File("${project.buildDir.absolutePath}${File.separator}javacard${File.separator}${capItem.output}").absolutePath
347 |             } else {
348 |                 file2Add = new File(capItem.output).absolutePath
349 |             }
350 | 
351 |             // Deletion tasks (package, applets)
352 |             def curDelTasksSpecs = []
353 |             def curDelTasks = []
354 | 
355 |             // Delete each applet first
356 |             capItem.applets.eachWithIndex { Applet appletItem, int idx ->
357 |                 def lstCls = appletItem.className.split("\\.").last().capitalize()
358 |                 def taskName = "${DELETE_TASK}Package${String.format("%02d", capIdx)}Applet${String.format("%02d", idx)}$lstCls"
359 |                 def tmpArgs = ["--delete", appletItem.aid]
360 |                 def taskDesc = "Removes applet \"${appletItem.className}\" (${appletItem.aid}) from the card"
361 |                 curDelTasksSpecs.add(new Tuple3(taskName, tmpArgs, taskDesc))
362 |             }
363 | 
364 |             // Then the package
365 |             def pkgAbrev = capItem.packageName.split("\\.").last().capitalize()
366 |             curDelTasksSpecs.add(new Tuple3(
367 |                     "${DELETE_TASK}Package${String.format("%02d", capIdx)}$pkgAbrev",
368 |                     ["--delete", capItem.aid],
369 |                     "Removes package \"${capItem.packageName}\" (${capItem.aid}) from the card"))
370 | 
371 |             // Create tasks from specs, the last one if package del
372 |             curDelTasksSpecs.eachWithIndex { tpl, taskIdx ->
373 |                 def (taskName, tmpArgs, taskDesc) = tpl
374 |                 tmpArgs = Utility.addKeyArg(extension.key, extension.defaultKey, tmpArgs)
375 |                 tmpArgs = Utility.addGpProArgs(extension, tmpArgs)
376 |                 tmpArgs = Utility.addAuxGpProArgs(extension.config.installGpProArgs, tmpArgs)
377 | 
378 |                 def tmpTask = project.tasks.create(name: taskName, type: GpExec)
379 |                 tmpTask.setIgnoreExitValue(true)
380 | 
381 |                 createGpExec(tmpTask, GLOBAL_PLATFORM_HELPER_GROUP, taskDesc, tmpArgs)
382 |                 curDelTasks.add(tmpTask)
383 |             }
384 | 
385 |             // Make package del depend on all applets del
386 |             def pkgDelTask = curDelTasks.last()
387 |             pkgDelTask.mustRunAfter preCardTask
388 |             curDelTasks[0 ..< (curDelTasks.size()-1)].each { ctask ->
389 |                 pkgDelTask.dependsOn ctask
390 |                 ctask.mustRunAfter preCardTask
391 |             }
392 | 
393 |             // Package del aggregation
394 |             delTasks.add(pkgDelTask)
395 | 
396 |             args.add('--install')
397 |             args.add(file2Add)
398 |         }
399 | 
400 |         def pkgDel = project.tasks.create(name: "${DELETE_TASK}Packages", type: DefaultTask)
401 |         createTask(pkgDel, GLOBAL_PLATFORM_GROUP, "Removes all packages from the card")
402 | 
403 |         pkgDel.dependsOn preCardTask
404 |         delTasks.each { it ->
405 |             pkgDel.dependsOn it
406 |         }
407 | 
408 |         def install = project.tasks.create(name: INSTALL_TASK, type: GpExec)
409 |         install.dependsOn buildTask
410 |         install.dependsOn preCardTask
411 |         install.dependsOn pkgDel
412 | 
413 |         args = Utility.addKeyArg(extension.key, extension.defaultKey, args)
414 |         args = Utility.addGpProArgs(extension, args)
415 |         args = Utility.addAuxGpProArgs(extension.config.installGpProArgs, args)
416 |         createGpExec(install, GLOBAL_PLATFORM_GROUP, 'install cap file', args)
417 |     }
418 | 
419 |     /**
420 |      * Create GpExec list applet task
421 |      *
422 |      * @param project gradle project
423 |      * @return
424 |      */
425 |     def createListTask(Project project, JavaCard extension) {
426 | 
427 |         def args = ['-l']
428 | 
429 |         args = Utility.addKeyArg(extension.key, extension.defaultKey, args)
430 |         args = Utility.addGpProArgs(extension, args)
431 | 
432 |         def script = project.tasks.create(name: LIST_TASK, type: GpExec)
433 |         createGpExec(script, GLOBAL_PLATFORM_GROUP, 'list applets', args)
434 |     }
435 | 
436 |     /**
437 |      * Create GpExec apdu script task.
438 |      *
439 |      * @param project gradle project
440 |      * @param taskName task name
441 |      * @param args
442 |      * @return
443 |      */
444 |     def createScriptTask(Project project, String taskName, args) {
445 |         def script = project.tasks.create(name: taskName, type: GpExec)
446 |         createGpExec(script, GLOBAL_PLATFORM_GROUP, 'apdu script', args)
447 |     }
448 | 
449 |     /**
450 |      * Create GpExec task
451 |      *
452 |      * @param project gradle project
453 |      * @param task gradle task object
454 |      * @param grp group name
455 |      * @param desc task description
456 |      * @param arguments arguments to gp tool
457 |      * @return
458 |      */
459 |     def createGpExec(Task task, String grp, String desc, arguments) {
460 |         task.configure {
461 |             group = grp
462 |             description = desc
463 |             args(arguments)
464 |             doFirst {
465 |                 println("gp ${arguments}")
466 |             }
467 |         }
468 |     }
469 | 
470 |     def createTask(Task task, String grp, String desc) {
471 |         task.configure {
472 |             group = grp
473 |             description = desc
474 |         }
475 |     }
476 | }


--------------------------------------------------------------------------------